This source file includes following definitions.
- Wait
- Wait
- Free
- Test
- Test
- Waitany
- Waitany
- Testany
- Testany
- Waitall
- Waitall
- Testall
- Testall
- Waitsome
- Waitsome
- Testsome
- Testsome
- Cancel
- Start
- Startall
- Get_status
- Get_status
- Start
- Complete
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 
  25 
  26 inline void
  27 MPI::Request::Wait(MPI::Status &status)
  28 {
  29   (void)MPI_Wait(&mpi_request, &status.mpi_status);
  30 }
  31 
  32 inline void
  33 MPI::Request::Wait()
  34 {
  35   (void)MPI_Wait(&mpi_request, MPI_STATUS_IGNORE);
  36 }
  37 
  38 inline void
  39 MPI::Request::Free()
  40 {
  41   (void)MPI_Request_free(&mpi_request);
  42 }
  43 
  44 inline bool
  45 MPI::Request::Test(MPI::Status &status)
  46 {
  47   int t;
  48   (void)MPI_Test(&mpi_request, &t, &status.mpi_status);
  49   return OPAL_INT_TO_BOOL(t);
  50 }
  51 
  52 inline bool
  53 MPI::Request::Test()
  54 {
  55   int t;
  56   (void)MPI_Test(&mpi_request, &t, MPI_STATUS_IGNORE);
  57   return OPAL_INT_TO_BOOL(t);
  58 }
  59 
  60 inline int
  61 MPI::Request::Waitany(int count, MPI::Request array[],
  62                              MPI::Status& status)
  63 {
  64   int index, i;
  65   MPI_Request* array_of_requests = new MPI_Request[count];
  66   for (i=0; i < count; i++) {
  67     array_of_requests[i] = array[i];
  68   }
  69   (void)MPI_Waitany(count, array_of_requests, &index, &status.mpi_status);
  70   for (i=0; i < count; i++) {
  71     array[i] = array_of_requests[i];
  72   }
  73   delete [] array_of_requests;
  74   return index;
  75 }
  76 
  77 inline int
  78 MPI::Request::Waitany(int count, MPI::Request array[])
  79 {
  80   int index, i;
  81   MPI_Request* array_of_requests = new MPI_Request[count];
  82   for (i=0; i < count; i++) {
  83     array_of_requests[i] = array[i];
  84   }
  85   (void)MPI_Waitany(count, array_of_requests, &index, MPI_STATUS_IGNORE);
  86   for (i=0; i < count; i++) {
  87     array[i] = array_of_requests[i];
  88   }
  89   delete [] array_of_requests;
  90   return index; 
  91 }
  92 
  93 inline bool
  94 MPI::Request::Testany(int count, MPI::Request array[],
  95                              int& index, MPI::Status& status)
  96 {
  97   int i, flag;
  98   MPI_Request* array_of_requests = new MPI_Request[count];
  99   for (i=0; i < count; i++) {
 100     array_of_requests[i] = array[i];
 101   }
 102   (void)MPI_Testany(count, array_of_requests, &index, &flag, &status.mpi_status);
 103   for (i=0; i < count; i++) {
 104     array[i] = array_of_requests[i];
 105   }
 106   delete [] array_of_requests;
 107   return (bool)(flag != 0 ? true : false);
 108 }
 109 
 110 inline bool
 111 MPI::Request::Testany(int count, MPI::Request array[], int& index)
 112 {
 113   int i, flag;
 114   MPI_Request* array_of_requests = new MPI_Request[count];
 115   for (i=0; i < count; i++) {
 116     array_of_requests[i] = array[i];
 117   }
 118   (void)MPI_Testany(count, array_of_requests, &index, &flag,
 119                     MPI_STATUS_IGNORE);
 120   for (i=0; i < count; i++) {
 121     array[i] = array_of_requests[i];
 122   }
 123   delete [] array_of_requests;
 124   return OPAL_INT_TO_BOOL(flag);
 125 }
 126 
 127 inline void
 128 MPI::Request::Waitall(int count, MPI::Request req_array[],
 129                              MPI::Status stat_array[])
 130 {
 131   int i;
 132   MPI_Request* array_of_requests = new MPI_Request[count];
 133   MPI_Status* array_of_statuses = new MPI_Status[count];
 134   for (i=0; i < count; i++) {
 135     array_of_requests[i] = req_array[i];
 136   }
 137   (void)MPI_Waitall(count, array_of_requests, array_of_statuses);
 138   for (i=0; i < count; i++) {
 139     req_array[i] = array_of_requests[i];
 140     stat_array[i] = array_of_statuses[i];
 141   }
 142   delete [] array_of_requests;
 143   delete [] array_of_statuses;
 144 }
 145 
 146 inline void
 147 MPI::Request::Waitall(int count, MPI::Request req_array[])
 148 {
 149   int i;
 150   MPI_Request* array_of_requests = new MPI_Request[count];
 151 
 152   for (i=0; i < count; i++) {
 153     array_of_requests[i] = req_array[i];
 154   }
 155   (void)MPI_Waitall(count, array_of_requests, MPI_STATUSES_IGNORE);
 156 
 157   for (i=0; i < count; i++) {
 158     req_array[i] = array_of_requests[i];
 159   }
 160 
 161   delete [] array_of_requests;
 162 }
 163 
 164 inline bool
 165 MPI::Request::Testall(int count, MPI::Request req_array[],
 166                              MPI::Status stat_array[])
 167 {
 168   int i, flag;
 169   MPI_Request* array_of_requests = new MPI_Request[count];
 170   MPI_Status* array_of_statuses = new MPI_Status[count];
 171   for (i=0; i < count; i++) {
 172     array_of_requests[i] = req_array[i];
 173   }
 174   (void)MPI_Testall(count, array_of_requests, &flag, array_of_statuses);
 175   for (i=0; i < count; i++) {
 176     req_array[i] = array_of_requests[i];
 177     stat_array[i] = array_of_statuses[i];
 178   }
 179   delete [] array_of_requests;
 180   delete [] array_of_statuses;
 181   return OPAL_INT_TO_BOOL(flag);
 182 }
 183 
 184 inline bool
 185 MPI::Request::Testall(int count, MPI::Request req_array[])
 186 {
 187   int i, flag;
 188   MPI_Request* array_of_requests = new MPI_Request[count];
 189 
 190   for (i=0; i < count; i++) {
 191     array_of_requests[i] = req_array[i];
 192   }
 193   (void)MPI_Testall(count, array_of_requests, &flag, MPI_STATUSES_IGNORE);
 194 
 195   for (i=0; i < count; i++) {
 196     req_array[i] = array_of_requests[i];
 197   }
 198   delete [] array_of_requests;
 199 
 200   return OPAL_INT_TO_BOOL(flag);
 201 }
 202 
 203 inline int
 204 MPI::Request::Waitsome(int incount, MPI::Request req_array[],
 205                               int array_of_indices[], MPI::Status stat_array[])
 206 {
 207   int i, outcount;
 208   MPI_Request* array_of_requests = new MPI_Request[incount];
 209   MPI_Status* array_of_statuses = new MPI_Status[incount];
 210   for (i=0; i < incount; i++) {
 211     array_of_requests[i] = req_array[i];
 212   }
 213   (void)MPI_Waitsome(incount, array_of_requests, &outcount,
 214                      array_of_indices, array_of_statuses);
 215   for (i=0; i < incount; i++) {
 216     req_array[i] = array_of_requests[i];
 217     stat_array[i] = array_of_statuses[i];
 218   }
 219   delete [] array_of_requests;
 220   delete [] array_of_statuses;
 221   return outcount;
 222 }
 223 
 224 inline int
 225 MPI::Request::Waitsome(int incount, MPI::Request req_array[],
 226                               int array_of_indices[])
 227 {
 228   int i, outcount;
 229   MPI_Request* array_of_requests = new MPI_Request[incount];
 230 
 231   for (i=0; i < incount; i++) {
 232     array_of_requests[i] = req_array[i];
 233   }
 234   (void)MPI_Waitsome(incount, array_of_requests, &outcount,
 235                      array_of_indices, MPI_STATUSES_IGNORE);
 236 
 237   for (i=0; i < incount; i++) {
 238     req_array[i] = array_of_requests[i];
 239   }
 240   delete [] array_of_requests;
 241 
 242   return outcount;
 243 }
 244 
 245 inline int
 246 MPI::Request::Testsome(int incount, MPI::Request req_array[],
 247                               int array_of_indices[], MPI::Status stat_array[])
 248 {
 249   int i, outcount;
 250   MPI_Request* array_of_requests = new MPI_Request[incount];
 251   MPI_Status* array_of_statuses = new MPI_Status[incount];
 252   for (i=0; i < incount; i++) {
 253     array_of_requests[i] = req_array[i];
 254   }
 255   (void)MPI_Testsome(incount, array_of_requests, &outcount,
 256                      array_of_indices, array_of_statuses);
 257   for (i=0; i < incount; i++) {
 258     req_array[i] = array_of_requests[i];
 259     stat_array[i] = array_of_statuses[i];
 260   }
 261   delete [] array_of_requests;
 262   delete [] array_of_statuses;
 263   return outcount;
 264 }
 265 
 266 inline int
 267 MPI::Request::Testsome(int incount, MPI::Request req_array[],
 268                               int array_of_indices[])
 269 {
 270   int i, outcount;
 271   MPI_Request* array_of_requests = new MPI_Request[incount];
 272 
 273   for (i=0; i < incount; i++) {
 274     array_of_requests[i] = req_array[i];
 275   }
 276   (void)MPI_Testsome(incount, array_of_requests, &outcount,
 277                      array_of_indices, MPI_STATUSES_IGNORE);
 278 
 279   for (i=0; i < incount; i++) {
 280     req_array[i] = array_of_requests[i];
 281   }
 282   delete [] array_of_requests;
 283 
 284   return outcount;
 285 }
 286 
 287 inline void
 288 MPI::Request::Cancel(void) const
 289 {
 290   (void)MPI_Cancel(const_cast<MPI_Request *>(&mpi_request));
 291 }
 292 
 293 inline void
 294 MPI::Prequest::Start()
 295 {
 296   (void)MPI_Start(&mpi_request);
 297 }
 298 
 299 inline void
 300 MPI::Prequest::Startall(int count, MPI:: Prequest array_of_requests[])
 301 {
 302   
 303   MPI_Request* mpi_requests = new MPI_Request[count];
 304   int i;
 305   for (i=0; i < count; i++) {
 306     mpi_requests[i] = array_of_requests[i];
 307   }
 308   (void)MPI_Startall(count, mpi_requests);
 309   for (i=0; i < count; i++) {
 310     array_of_requests[i].mpi_request = mpi_requests[i] ;
 311   }
 312   delete [] mpi_requests;
 313 }
 314 
 315 inline bool MPI::Request::Get_status(MPI::Status& status) const
 316 {
 317     int flag = 0;
 318     MPI_Status c_status;
 319 
 320     
 321     
 322     
 323     (void)MPI_Request_get_status(mpi_request, &flag, &c_status);
 324     if (flag) {
 325         status = c_status;
 326     }
 327     return OPAL_INT_TO_BOOL(flag);
 328 }
 329 
 330 inline bool MPI::Request::Get_status() const
 331 {
 332     int flag;
 333 
 334     
 335     
 336     
 337     (void)MPI_Request_get_status(mpi_request, &flag, MPI_STATUS_IGNORE);
 338     return OPAL_INT_TO_BOOL(flag);
 339 }
 340 
 341 inline MPI::Grequest
 342 MPI::Grequest::Start(Query_function *query_fn, Free_function *free_fn,
 343         Cancel_function *cancel_fn, void *extra)
 344 {
 345     MPI_Request grequest = 0;
 346     Intercept_data_t *new_extra =
 347         new MPI::Grequest::Intercept_data_t;
 348 
 349     new_extra->id_extra = extra;
 350     new_extra->id_cxx_query_fn = query_fn;
 351     new_extra->id_cxx_free_fn = free_fn;
 352     new_extra->id_cxx_cancel_fn = cancel_fn;
 353     (void) MPI_Grequest_start(ompi_mpi_cxx_grequest_query_fn_intercept,
 354                               ompi_mpi_cxx_grequest_free_fn_intercept,
 355                               ompi_mpi_cxx_grequest_cancel_fn_intercept,
 356                               new_extra, &grequest);
 357 
 358     return(grequest);
 359 }
 360 
 361 inline void
 362 MPI::Grequest::Complete()
 363 {
 364     (void) MPI_Grequest_complete(mpi_request);
 365 }
 366