AMROC - Source code documentation

00001 
00006 #include "CommIOServer.h"
00007 
00008 #include "GridHierarchy.h"
00009 
00010 /*************************************************************************/
00011 /* DAGHIOServerRcv */
00012 /*************************************************************************/
00013 DAGHIOServerRcv::DAGHIOServerRcv(unsigned const tag, 
00014                                  GridHierarchy& gridhierarchy,
00015                                  DAGHIO_WriteFunc writefunc)
00016         : comm_service(DAGHNull,tag), gh(gridhierarchy), Size(0), wf(writefunc),
00017           end_cnt(0)
00018   {
00019 
00020 #ifdef DAGH_NO_MPI
00021 #else
00022 
00023 #ifdef DEBUG_PRINT_COMM_IO
00024    ( comm_service::log() << "DAGHIOServerRcv::DAGHIOServerRcv " 
00025                          << comm_service::proc_me() << " "
00026                          << " MPI_Irecv: "
00027                          << "Tag: " << Tag << " " 
00028                          << "Size: " << 1 << " "
00029                          << endl ).flush();
00030 #endif
00031 
00032     int R = MPI_Irecv(&Size,1,MPI_INT,MPI_ANY_SOURCE,Tag,
00033                       comm_service::comm_io(),req());
00034 
00035     if ( MPI_SUCCESS != R ) 
00036       comm_service::error_die("DAGHIOServerRcv::DAGHIOServerRcv","MPI_Irecv",R);
00037 
00038 #endif
00039 
00040   }
00041 
00042 void DAGHIOServerRcv::callrecv( const MPI_Status & MS )
00043   {
00044     if (Size == DAGHNull) {
00045       if (++end_cnt == comm_service::proc_num()) {
00046 #ifdef DEBUG_PRINT_COMM_IO
00047    ( comm_service::log() << "DAGHIOServerRcv::callrecv " 
00048                          << comm_service::proc_me() << " "
00049                          << "EndCnt = " << end_cnt << " "
00050                          << "Ending ServerRcv"
00051                          << endl ).flush();
00052 #endif
00053         return;
00054       }
00055       else {
00056 #ifdef DEBUG_PRINT_COMM_IO
00057    ( comm_service::log() << "DAGHIOServerRcv::callrecv " 
00058                          << comm_service::proc_me() << " "
00059                          << "EndCnt = " << end_cnt
00060                          << endl ).flush();
00061 #endif
00062       }
00063     }
00064     else {
00065       void *Rcv = (void*) new char[Size];
00066       assert (Rcv != 0);
00067 
00068 #ifdef DAGH_NO_MPI
00069 #else
00070 
00071       int from = MS.MPI_SOURCE;
00072 
00073 #ifdef DEBUG_PRINT_COMM_IO
00074       ( comm_service::log() << "DAGHIOServerRcv::callrecv " 
00075                             << comm_service::proc_me() << " "
00076                             << " MPI_Recv: "
00077                             << "Tag: " << (DAGHIOTag|DAGHIOWriteDataTag) << " " 
00078                             << "Size: " << Size << " "
00079                             << "From: " << from << " "
00080                             << endl ).flush();
00081 #endif
00082 
00083       MPI_Status status;
00084       int R = MPI_Recv(Rcv,Size,MPI_BYTE,from,(DAGHIOTag|DAGHIOWriteDataTag),
00085                        comm_service::comm_io(),&status);
00086       if ( MPI_SUCCESS != R ) 
00087         comm_service::error_die("DAGHIOServerRcv::callrecv","MPI_Recv",R);
00088 
00089 #endif
00090 
00091       if (Size > 0) rcv_update(Rcv);
00092       else {
00093         if (Rcv) delete [] (char *)Rcv;
00094       }
00095       Rcv = 0;
00096     }
00097 
00098 #ifdef DAGH_NO_MPI
00099 #else
00100 #ifdef DEBUG_PRINT_COMM_IO
00101    ( comm_service::log() << "DAGHIOServerRcv::callrecv " 
00102                          << comm_service::proc_me() << " "
00103                          << " MPI_Irecv: "
00104                          << "Tag: " << Tag << " " 
00105                          << "Size: " << 1 << " "
00106                          << endl ).flush();
00107 #endif
00108 
00109     int R = MPI_Irecv(&Size,1,MPI_INT,MPI_ANY_SOURCE,Tag,
00110                   comm_service::comm_io(),req());
00111     if ( MPI_SUCCESS != R )
00112       comm_service::error_die("DAGHIOServerRcv::callrecv","MPI_Irecv",R);
00113 
00114 #endif
00115   }
00116 
00117 void DAGHIOServerRcv::rcv_update(void *Rcv)
00118   {
00119    GridDataBucketVoid *rcvbkt = new GridDataBucketVoid(Rcv);
00120 
00121 #ifdef DEBUG_PRINT_COMM_IO
00122    ( comm_service::log() << "GridTableCommRcv::rcv_update " 
00123                          << comm_service::proc_me() << " "
00124                          << "Recieved { " 
00125                          << *rcvbkt->head() 
00126                          << " }" 
00127                          << endl ).flush();
00128 #endif
00129 
00130    const int type = rcvbkt->type();
00131 
00132    if (wf) {
00133      if (type == DAGHPacked) {
00134        int num = rcvbkt->num();
00135        for (int i=0;i<num;i++) {
00136 #ifdef DEBUG_PRINT_COMM_IO
00137        ( comm_service::log() << "GridTableCommRcv::rcv_update " 
00138                              << comm_service::proc_me() << " "
00139                              << "Writing (" << i << "){ " 
00140                              << *rcvbkt->head(i) 
00141                              << " }" 
00142                              << endl ).flush();
00143 #endif
00144          (wf)(gh, rcvbkt->head(i), rcvbkt->data(i));
00145        }
00146      }
00147      else {
00148 #ifdef DEBUG_PRINT_COMM_IO
00149        ( comm_service::log() << "GridTableCommRcv::rcv_update " 
00150                              << comm_service::proc_me() << " "
00151                              << "Writing { " 
00152                              << *rcvbkt->head() 
00153                              << " }" 
00154                              << endl ).flush();
00155 #endif
00156        (wf)(gh, rcvbkt->head(),rcvbkt->data());
00157      }
00158    }
00159    else {
00160      cerr << "DAGHIOServerRcv::rcv_update: WriteFunc not set" << "\n";
00161    }
00162 
00163    delete rcvbkt;
00164    rcvbkt = 0;
00165   }
00166 
00167 const char * DAGHIOServerRcv::name( void ) const
00168   {
00169    static const char Name[] = "DAGHIOServerRcv" ;
00170    return Name ;
00171   }
00172 
00173 /*************************************************************************/
00174 /* DAGHIOServerSnd */
00175 /*************************************************************************/
00176 DAGHIOServerSnd::DAGHIOServerSnd(const unsigned tag, 
00177                                  GridHierarchy& gridhierarchy,
00178                                  DAGHIO_ReadFunc readfunc)
00179         :comm_service(DAGHNull,tag), gh(gridhierarchy), 
00180          rf(readfunc), Size(sizeof(struct gdhdr)), end_cnt(0)
00181   {
00182 #ifdef DAGH_NO_MPI
00183 #else
00184 
00185 #ifdef DEBUG_PRINT_COMM_IO
00186    ( comm_service::log() << "DAGHIOServerSnd::DAGHIOServerSnd " 
00187                          << comm_service::proc_me() << " "
00188                          << " MPI_Irecv: "
00189                          << "Tag: " << Tag << " " 
00190                          << "Size: " << Size << " "
00191                          << endl ).flush();
00192 #endif
00193 
00194     int R = MPI_Irecv(&Req,sizeof(struct gdhdr),MPI_BYTE,
00195                       MPI_ANY_SOURCE,Tag,comm_service::comm_io(),req());
00196     if ( MPI_SUCCESS != R ) 
00197       comm_service::error_die("DAGHIOServerSnd::DAGHIOServerSnd","MPI_Irecv",R);
00198 
00199 #endif
00200 
00201   }
00202 
00203 void DAGHIOServerSnd::callrecv( const MPI_Status & MS )
00204   {
00205     if (Req.type == DAGHNull) {
00206       if (++end_cnt == comm_service::proc_num()){
00207 #ifdef DEBUG_PRINT_COMM_IO
00208    ( comm_service::log() << "DAGHIOServerSnd::callrecv " 
00209                          << comm_service::proc_me() << " "
00210                          << "EndCnt = " << end_cnt << " "
00211                          << "Ending ServerSnd"
00212                          << endl ).flush();
00213 #endif
00214          return;
00215       }
00216       else {
00217 #ifdef DEBUG_PRINT_COMM_IO
00218    ( comm_service::log() << "DAGHIOServerSnd::callrecv " 
00219                          << comm_service::proc_me() << " "
00220                          << "EndCnt = " << end_cnt
00221                          << endl ).flush();
00222 #endif
00223       }
00224     }
00225     else {
00226       snd_update( Req );
00227     } 
00228 
00229 #ifdef DAGH_NO_MPI
00230 #else
00231 
00232 #ifdef DEBUG_PRINT_COMM_IO
00233    ( comm_service::log() << "DAGHIOServerSnd::callrecv " 
00234                          << comm_service::proc_me() << " "
00235                          << " MPI_Irecv: "
00236                          << "Tag: " << Tag << " " 
00237                          << "Size: " << Size << " "
00238                          << endl ).flush();
00239 #endif
00240 
00241     int R = MPI_Irecv(&Req,sizeof(struct gdhdr),MPI_BYTE,
00242                       MPI_ANY_SOURCE,Tag,comm_service::comm_io(),req());
00243     if ( MPI_SUCCESS != R ) 
00244       comm_service::error_die("DAGHIOServerSnd::callrecv","MPI_Irecv",R);
00245 
00246 #endif
00247 
00248   }
00249 
00250 void DAGHIOServerSnd::snd_update(struct gdhdr& Req)
00251   {
00252 
00253 #ifdef DEBUG_PRINT_COMM_IO
00254    ( comm_service::log() << "DAGHIOServerSnd::snd_update " 
00255                          << comm_service::proc_me() << " "
00256                          << "Request("
00257                          << Req
00258                          << ")"
00259                          << endl ).flush();
00260 #endif
00261 
00262    GridDataBucketVoid *bkt = 
00263                 new GridDataBucketVoid(Req,DAGHIO_DataSize(Req.gfdatatype));
00264 
00265    if (rf) {
00266      (rf)(gh, bkt->head(),bkt->data());
00267    }
00268    else {
00269      cerr << "DAGHIOServerSnd::snd_update: ReadFunc not set" << "\n";
00270    }
00271 
00272    void *package = 0; unsigned size;
00273    bkt->pack(package,size);
00274 
00275 #ifdef DAGH_NO_MPI
00276 #else
00277    const unsigned T = (DAGHIOTag|DAGHIOReadDataTag|Req.index);
00278    const int dest = bkt->owner();
00279 
00280 #ifdef DEBUG_PRINT_COMM_IO
00281    ( comm_service::log() << "DAGHIOServerSnd::snd_update" << " " 
00282                          << comm_service::proc_me() << " "
00283                          << "MPI_Rsend: " << " "
00284                          << T << " "
00285                          << "Size: " << size << " "
00286                          << "Dest: " << dest << " "
00287                          << endl ).flush();
00288 #endif
00289 
00290    int R = MPI_Rsend(package, size, MPI_BYTE, dest,
00291                      T, comm_service::comm_io() );
00292 
00293    if ( MPI_SUCCESS != R )
00294      comm_service::error_die("DAGHIOServerSnd::snd_update","MPI_Rsend",R);
00295 
00296 #endif
00297 
00298    delete bkt;
00299   }
00300 
00301 const char * DAGHIOServerSnd::name( void ) const
00302   {
00303    static const char Name[] = "DAGHIOServerSnd" ;
00304    return Name ;
00305   }
00306 
00307 /*************************************************************************/
00308 /* DAGHIOServerPing */
00309 /*************************************************************************/
00310 DAGHIOServerPing::DAGHIOServerPing(const unsigned tag, 
00311                                    GridHierarchy& gridhierarchy,
00312                                    DAGHIO_PingFunc pingfunc)
00313         : comm_service(DAGHNull,tag), gh(gridhierarchy), pf(pingfunc),
00314           flag(DAGHTrue), end_cnt(0)
00315   {
00316 
00317 #ifdef DAGH_NO_MPI
00318 #else
00319 
00320 #ifdef DEBUG_PRINT_COMM_IO
00321    ( comm_service::log() << "DAGHIOServerPing::DAGHIOServerPing " 
00322                          << comm_service::proc_me() << " "
00323                          << " MPI_Irecv: "
00324                          << "Tag: " << Tag << " " 
00325                          << "Size: " << 0 << " "
00326                          << endl ).flush();
00327 #endif
00328 
00329     int R = MPI_Irecv(&flag,1,MPI_INT,MPI_ANY_SOURCE,Tag,
00330                       comm_service::comm_io(),req());
00331     if ( MPI_SUCCESS != R ) 
00332       comm_service::error_die("DAGHIOServerPing::DAGHIOServerPing","MPI_Irecv",R);
00333 
00334 #endif
00335 
00336   }
00337 
00338 void DAGHIOServerPing::callrecv( const MPI_Status & MS )
00339   {
00340     if (flag == DAGHFalse) {
00341       if (++end_cnt == comm_service::proc_num()) {
00342 #ifdef DEBUG_PRINT_COMM_IO
00343    ( comm_service::log() << "DAGHIOServerPing::callrecv " 
00344                          << comm_service::proc_me() << " "
00345                          << "EndCnt = " << end_cnt << " "
00346                          << "Ending ServerPing"
00347                          << endl ).flush();
00348 #endif
00349         return;
00350       }
00351       else {
00352 #ifdef DEBUG_PRINT_COMM_IO
00353    ( comm_service::log() << "DAGHIOServerPing::callrecv " 
00354                          << comm_service::proc_me() << " "
00355                          << "EndCnt = " << end_cnt
00356                          << endl ).flush();
00357 #endif
00358       }
00359     }
00360     else {
00361       if (pf) {
00362         (pf) (gh);
00363       }
00364       else {
00365         cerr << "DAGHIOServerPing::callrecv: PingFunc not set" << "\n";
00366       }
00367     }
00368 
00369     if (!comm_service::comminit()) return;
00370 
00371 #ifdef DAGH_NO_MPI
00372 #else
00373 
00374 #ifdef DEBUG_PRINT_COMM_IO
00375    ( comm_service::log() << "DAGHIOServerPing::callrecv " 
00376                          << comm_service::proc_me() << " "
00377                          << " MPI_Irecv: "
00378                          << "Tag: " << Tag << " " 
00379                          << "Size: " << 0 << " "
00380                          << endl ).flush();
00381 #endif
00382 
00383     flag = DAGHTrue;
00384     int R = MPI_Irecv(&flag,1,MPI_INT,MPI_ANY_SOURCE,Tag,
00385                       comm_service::comm_io(),req());
00386     if ( MPI_SUCCESS != R ) 
00387       comm_service::error_die("DAGHIOServerPing::commrecv","MPI_Irecv",R);
00388 
00389 #endif
00390   }
00391 
00392 const char * DAGHIOServerPing::name( void ) const
00393   {
00394    static const char Name[] = "DAGHIOServerPing" ;
00395    return Name ;
00396   }
CommIOServer.C

last update: 06/01/04
