mess.cpp

00001 /* 
00002 * <mess.cpp>
00003 * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
00004 * (C) OPAC Team, LIFL, 2002-2007
00005 *
00006 * Sebastien Cahon, Alexandru-Adrian Tantar
00007 *
00008 * This software is governed by the CeCILL license under French law and
00009 * abiding by the rules of distribution of free software.  You can  use,
00010 * modify and/ or redistribute the software under the terms of the CeCILL
00011 * license as circulated by CEA, CNRS and INRIA at the following URL
00012 * "http://www.cecill.info".
00013 *
00014 * As a counterpart to the access to the source code and  rights to copy,
00015 * modify and redistribute granted by the license, users are provided only
00016 * with a limited warranty  and the software's author,  the holder of the
00017 * economic rights,  and the successive licensors  have only  limited liability.
00018 *
00019 * In this respect, the user's attention is drawn to the risks associated
00020 * with loading,  using,  modifying and/or developing or reproducing the
00021 * software by the user in light of its specific status of free software,
00022 * that may mean  that it is complicated to manipulate,  and  that  also
00023 * therefore means  that it is reserved for developers  and  experienced
00024 * professionals having in-depth computer knowledge. Users are therefore
00025 * encouraged to load and test the software's suitability as regards their
00026 * requirements in conditions enabling the security of their systems and/or
00027 * data to be ensured and,  more generally, to use and operate it in the
00028 * same conditions as regards security.
00029 * The fact that you are presently reading this means that you have had
00030 * knowledge of the CeCILL license and that you accept its terms.
00031 *
00032 * ParadisEO WebSite : http://paradiseo.gforge.inria.fr
00033 * Contact: paradiseo-help@lists.gforge.inria.fr
00034 *
00035 */
00036 
00037 #include <mpi.h>
00038 #include <vector>
00039 
00040 #include "mess.h"
00041 #include "../../core/peo_debug.h"
00042 #include "node.h"
00043 
00044 #define MPI_BUF_SIZE 1024*64
00045         
00046 static char mpi_buf [MPI_BUF_SIZE];
00047         
00048 static int pos_buf ;
00049 
00050 static std :: vector <char *> act_buf; /* Active buffers */
00051 
00052 static std :: vector <MPI_Request *> act_req; /* Active requests */
00053 
00054 void cleanBuffers () {
00055 
00056   for (unsigned i = 0; i < act_req.size ();) {
00057        
00058     MPI_Status stat ;
00059     int flag ;
00060     MPI_Test (act_req [i], & flag, & stat) ;
00061     if (flag) {
00062       
00063       delete act_buf [i] ;
00064       delete act_req [i] ;
00065         
00066       act_buf [i] = act_buf.back () ;
00067       act_buf.pop_back () ;
00068       
00069       act_req [i] = act_req.back () ;
00070       act_req.pop_back () ;
00071     }
00072     else
00073       i ++;
00074   } 
00075 }
00076 
00077 void waitBuffers () {
00078 
00079   printDebugMessage ("waiting the termination of the asynchronous operations to complete");
00080 
00081   for (unsigned i = 0; i < act_req.size (); i ++) {
00082        
00083     MPI_Status stat ;
00084 
00085     MPI_Wait (act_req [i], & stat) ;
00086       
00087     delete act_buf [i] ;
00088     delete act_req [i] ;
00089   } 
00090 }
00091 
00092 bool probeMessage (int & __src, int & __tag) {
00093 
00094   int flag;
00095 
00096   MPI_Status stat;
00097 
00098   MPI_Iprobe (MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, & flag, & stat);
00099 
00100   __src = stat.MPI_SOURCE;
00101   __tag = stat.MPI_TAG;
00102 
00103   return flag;
00104 }
00105 
00106 void waitMessage () {
00107 
00108   MPI_Status stat;  
00109 
00110   MPI_Probe (MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, & stat);
00111 }
00112 
00113 void initMessage () {
00114   
00115   pos_buf = 0;
00116 }
00117 
00118 void sendMessage (int __to, int __tag) {
00119 
00120   cleanBuffers ();  
00121   act_buf.push_back (new char [pos_buf]);
00122   act_req.push_back (new MPI_Request);  
00123   memcpy (act_buf.back (), mpi_buf, pos_buf);  
00124   MPI_Isend (act_buf.back (), pos_buf, MPI_PACKED, __to, __tag, MPI_COMM_WORLD, act_req.back ()); 
00125 }
00126 
00127 void sendMessageToAll (int __tag) {
00128 
00129   for (int i = 0; i < getNumberOfNodes (); i ++)
00130     sendMessage (i, __tag);
00131 }
00132 
00133 void receiveMessage (int __from, int __tag) {
00134   
00135   MPI_Status stat;  
00136   MPI_Request req;
00137 
00138   MPI_Irecv (mpi_buf, MPI_BUF_SIZE, MPI_PACKED, __from, __tag, MPI_COMM_WORLD, & req) ;
00139   MPI_Wait (& req, & stat) ;
00140 }
00141 
00142 /* Char */
00143 void pack (const char & __c) {
00144 
00145   MPI_Pack ((void *) & __c, 1, MPI_CHAR, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00146 }
00147 
00148 /* Float */
00149 void pack (const float & __f, int __nitem) {
00150 
00151   MPI_Pack ((void *) & __f, __nitem, MPI_FLOAT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00152 }
00153 
00154 /* Double */
00155 void pack (const double & __d, int __nitem) {
00156 
00157   MPI_Pack ((void *) & __d, __nitem, MPI_DOUBLE, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00158 }
00159 
00160 /* Integer */
00161 void pack (const int & __i, int __nitem) {
00162 
00163   MPI_Pack ((void *) & __i, __nitem, MPI_INT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00164 }
00165 
00166 /* Unsigned int. */
00167 void pack (const unsigned int & __ui, int __nitem) {
00168 
00169   MPI_Pack ((void *) & __ui, __nitem, MPI_UNSIGNED, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00170 }
00171 
00172 /* Short int. */
00173 void pack (const short & __sh, int __nitem) {
00174 
00175   MPI_Pack ((void *) & __sh, __nitem, MPI_SHORT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00176 }
00177 
00178 /* Unsigned short */
00179 void pack (const unsigned short & __ush, int __nitem) {
00180 
00181   MPI_Pack ((void *) & __ush, __nitem, MPI_UNSIGNED_SHORT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00182 }
00183 
00184 /* Long */
00185 void pack (const long & __l, int __nitem) {
00186 
00187   MPI_Pack ((void *) & __l, __nitem, MPI_LONG, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00188 }
00189 
00190 /* Unsigned long */
00191 void pack (const unsigned long & __ul, int __nitem) {
00192 
00193   MPI_Pack ((void *) & __ul, __nitem, MPI_UNSIGNED_LONG, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00194 }
00195 
00196 /* String */
00197 void pack (const char * __str) {
00198   
00199   int len = strlen (__str) + 1;
00200   MPI_Pack (& len, 1, MPI_INT, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00201   MPI_Pack ((void *) __str, len, MPI_CHAR, mpi_buf, MPI_BUF_SIZE, & pos_buf, MPI_COMM_WORLD);
00202 }
00203 
00204 /* Char */
00205 void unpack (char & __c) {
00206 
00207   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __c, 1, MPI_CHAR, MPI_COMM_WORLD);
00208 }
00209 
00210 /* Float */
00211 void unpack (float & __f, int __nitem) {
00212 
00213   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __f, __nitem, MPI_FLOAT, MPI_COMM_WORLD);
00214 }
00215 
00216 /* Double */
00217 void unpack (double & __d, int __nitem) {
00218 
00219   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __d, __nitem, MPI_DOUBLE, MPI_COMM_WORLD);
00220 }
00221 
00222 /* Integer */
00223 void unpack (int & __i, int __nitem) {
00224 
00225   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __i, __nitem, MPI_INT, MPI_COMM_WORLD);
00226 }
00227 
00228 /* Unsigned int. */
00229 void unpack (unsigned int & __ui, int __nitem) {
00230 
00231   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ui, __nitem, MPI_UNSIGNED, MPI_COMM_WORLD);
00232 }
00233 
00234 /* Short int. */
00235 void unpack (short & __sh, int __nitem) {
00236 
00237   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __sh, __nitem, MPI_SHORT, MPI_COMM_WORLD);
00238 }
00239 
00240 /* Unsigned short */
00241 void unpack (unsigned short & __ush, int __nitem) {
00242 
00243   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ush, __nitem, MPI_UNSIGNED_SHORT, MPI_COMM_WORLD);
00244 }
00245 
00246 /* Long */
00247 void unpack (long & __l, int __nitem) {
00248 
00249   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __l, __nitem, MPI_LONG, MPI_COMM_WORLD);
00250 }
00251 
00252 /* Unsigned long */
00253 void unpack (unsigned long & __ul, int __nitem) {
00254 
00255   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & __ul, __nitem, MPI_UNSIGNED_LONG, MPI_COMM_WORLD);
00256 }
00257 
00258 /* String */
00259 void unpack (char * __str) {
00260 
00261   int len;
00262   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, & len, 1, MPI_INT, MPI_COMM_WORLD);
00263   MPI_Unpack (mpi_buf, MPI_BUF_SIZE, & pos_buf, __str, len, MPI_CHAR, MPI_COMM_WORLD);    
00264 }
00265 

Generated on Mon Oct 8 11:16:45 2007 for ParadisEO-PEOMovingObjects by  doxygen 1.4.7