This source file includes following definitions.
- ompi_coll_base_sendrecv_zero
- ompi_coll_base_barrier_intra_doublering
- ompi_coll_base_barrier_intra_recursivedoubling
- ompi_coll_base_barrier_intra_bruck
- ompi_coll_base_barrier_intra_two_procs
- ompi_coll_base_barrier_intra_basic_linear
- ompi_coll_base_barrier_intra_tree
   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 #include "ompi_config.h"
  27 
  28 #include "mpi.h"
  29 #include "opal/util/bit_ops.h"
  30 #include "ompi/constants.h"
  31 #include "ompi/communicator/communicator.h"
  32 #include "ompi/mca/coll/coll.h"
  33 #include "ompi/mca/coll/base/coll_tags.h"
  34 #include "ompi/mca/pml/pml.h"
  35 #include "ompi/mca/coll/base/coll_base_functions.h"
  36 #include "coll_base_topo.h"
  37 #include "coll_base_util.h"
  38 
  39 
  40 
  41 
  42 
  43 
  44 static inline int
  45 ompi_coll_base_sendrecv_zero( int dest, int stag,
  46                               int source, int rtag,
  47                               MPI_Comm comm )
  48 
  49 {
  50     int rc, line = 0;
  51     ompi_request_t *req = MPI_REQUEST_NULL;
  52     ompi_status_public_t status;
  53 
  54     
  55     rc = MCA_PML_CALL(irecv( NULL, 0, MPI_BYTE, source, rtag,
  56                              comm, &req ));
  57     if( MPI_SUCCESS != rc ) { line = __LINE__; goto error_handler; }
  58 
  59     
  60     rc = MCA_PML_CALL(send( NULL, 0, MPI_BYTE, dest, stag,
  61                             MCA_PML_BASE_SEND_STANDARD, comm ));
  62     if( MPI_SUCCESS != rc ) { line = __LINE__; goto error_handler; }
  63 
  64     rc = ompi_request_wait( &req, &status );
  65     if( MPI_SUCCESS != rc ) { line = __LINE__; goto error_handler; }
  66 
  67     return (MPI_SUCCESS);
  68 
  69  error_handler:
  70     if( MPI_REQUEST_NULL != req ) {  
  71         (void)ompi_request_cancel(req);
  72         (void)ompi_request_wait(&req, &status);
  73     }
  74 
  75     OPAL_OUTPUT ((ompi_coll_base_framework.framework_output, "%s:%d: Error %d occurred\n",
  76                   __FILE__, line, rc));
  77     (void)line;  
  78     return rc;
  79 }
  80 
  81 
  82 
  83 
  84 
  85 
  86 
  87 
  88 
  89 
  90 
  91 
  92 
  93 
  94 
  95 
  96 
  97 
  98 
  99 
 100 int ompi_coll_base_barrier_intra_doublering(struct ompi_communicator_t *comm,
 101                                              mca_coll_base_module_t *module)
 102 {
 103     int rank, size, err = 0, line = 0, left, right;
 104 
 105     size = ompi_comm_size(comm);
 106     if( 1 == size )
 107         return OMPI_SUCCESS;
 108     rank = ompi_comm_rank(comm);
 109 
 110     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"ompi_coll_base_barrier_intra_doublering rank %d", rank));
 111 
 112     left = ((rank-1)%size);
 113     right = ((rank+1)%size);
 114 
 115     if (rank > 0) { 
 116         err = MCA_PML_CALL(recv((void*)NULL, 0, MPI_BYTE, left,
 117                                 MCA_COLL_BASE_TAG_BARRIER, comm,
 118                                 MPI_STATUS_IGNORE));
 119         if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl; }
 120     }
 121 
 122     
 123     err = MCA_PML_CALL(send((void*)NULL, 0, MPI_BYTE, right,
 124                             MCA_COLL_BASE_TAG_BARRIER,
 125                             MCA_PML_BASE_SEND_STANDARD, comm));
 126     if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;  }
 127 
 128     
 129     if (rank == 0) {
 130         err = MCA_PML_CALL(recv((void*)NULL, 0, MPI_BYTE, left,
 131                                 MCA_COLL_BASE_TAG_BARRIER, comm,
 132                                 MPI_STATUS_IGNORE));
 133         if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl; }
 134     }
 135 
 136     
 137     if (rank > 0) { 
 138         err = MCA_PML_CALL(recv((void*)NULL, 0, MPI_BYTE, left,
 139                                 MCA_COLL_BASE_TAG_BARRIER, comm,
 140                                 MPI_STATUS_IGNORE));
 141         if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl; }
 142     }
 143 
 144     
 145     err = MCA_PML_CALL(send((void*)NULL, 0, MPI_BYTE, right,
 146                             MCA_COLL_BASE_TAG_BARRIER,
 147                             MCA_PML_BASE_SEND_SYNCHRONOUS, comm));
 148     if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;  }
 149 
 150     
 151     if (rank == 0) {
 152         err = MCA_PML_CALL(recv((void*)NULL, 0, MPI_BYTE, left,
 153                                 MCA_COLL_BASE_TAG_BARRIER, comm,
 154                                 MPI_STATUS_IGNORE));
 155         if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;  }
 156     }
 157 
 158     return MPI_SUCCESS;
 159 
 160  err_hndl:
 161     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
 162                  __FILE__, line, err, rank));
 163     (void)line;  
 164     return err;
 165 }
 166 
 167 
 168 
 169 
 170 
 171 
 172 int ompi_coll_base_barrier_intra_recursivedoubling(struct ompi_communicator_t *comm,
 173                                                     mca_coll_base_module_t *module)
 174 {
 175     int rank, size, adjsize, err, line, mask, remote;
 176 
 177     size = ompi_comm_size(comm);
 178     if( 1 == size )
 179         return OMPI_SUCCESS;
 180     rank = ompi_comm_rank(comm);
 181     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
 182                  "ompi_coll_base_barrier_intra_recursivedoubling rank %d",
 183                  rank));
 184 
 185     
 186     adjsize = opal_next_poweroftwo(size);
 187     adjsize >>= 1;
 188 
 189     
 190     if (adjsize != size) {
 191         if (rank >= adjsize) {
 192             
 193             remote = rank - adjsize;
 194             err = ompi_coll_base_sendrecv_zero(remote, MCA_COLL_BASE_TAG_BARRIER,
 195                                                remote, MCA_COLL_BASE_TAG_BARRIER,
 196                                                comm);
 197             if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;}
 198 
 199         } else if (rank < (size - adjsize)) {
 200 
 201             
 202             err = MCA_PML_CALL(recv((void*)NULL, 0, MPI_BYTE, rank+adjsize,
 203                                     MCA_COLL_BASE_TAG_BARRIER, comm,
 204                                     MPI_STATUS_IGNORE));
 205 
 206             if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;}
 207         }
 208     }
 209 
 210     
 211     if ( rank < adjsize ) {
 212         mask = 0x1;
 213         while ( mask < adjsize ) {
 214             remote = rank ^ mask;
 215             mask <<= 1;
 216             if (remote >= adjsize) continue;
 217 
 218             
 219             err = ompi_coll_base_sendrecv_zero(remote, MCA_COLL_BASE_TAG_BARRIER,
 220                                                remote, MCA_COLL_BASE_TAG_BARRIER,
 221                                                comm);
 222             if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;}
 223         }
 224     }
 225 
 226     
 227     if (adjsize != size) {
 228         if (rank < (size - adjsize)) {
 229             
 230             remote = rank + adjsize;
 231             err = MCA_PML_CALL(send((void*)NULL, 0, MPI_BYTE, remote,
 232                                     MCA_COLL_BASE_TAG_BARRIER,
 233                                     MCA_PML_BASE_SEND_SYNCHRONOUS, comm));
 234 
 235             if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;}
 236         }
 237     }
 238 
 239     return MPI_SUCCESS;
 240 
 241  err_hndl:
 242     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
 243                  __FILE__, line, err, rank));
 244     (void)line;  
 245     return err;
 246 }
 247 
 248 
 249 
 250 
 251 
 252 
 253 int ompi_coll_base_barrier_intra_bruck(struct ompi_communicator_t *comm,
 254                                         mca_coll_base_module_t *module)
 255 {
 256     int rank, size, distance, to, from, err, line = 0;
 257 
 258     size = ompi_comm_size(comm);
 259     if( 1 == size )
 260         return MPI_SUCCESS;
 261     rank = ompi_comm_rank(comm);
 262     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
 263                  "ompi_coll_base_barrier_intra_bruck rank %d", rank));
 264 
 265     
 266     for (distance = 1; distance < size; distance <<= 1) {
 267         from = (rank + size - distance) % size;
 268         to   = (rank + distance) % size;
 269 
 270         
 271         err = ompi_coll_base_sendrecv_zero(to, MCA_COLL_BASE_TAG_BARRIER,
 272                                            from, MCA_COLL_BASE_TAG_BARRIER,
 273                                            comm);
 274         if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;}
 275     }
 276 
 277     return MPI_SUCCESS;
 278 
 279  err_hndl:
 280     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
 281                  __FILE__, line, err, rank));
 282     (void)line;  
 283     return err;
 284 }
 285 
 286 
 287 
 288 
 289 
 290 
 291 int ompi_coll_base_barrier_intra_two_procs(struct ompi_communicator_t *comm,
 292                                             mca_coll_base_module_t *module)
 293 {
 294     int remote, size, err;
 295 
 296     size = ompi_comm_size(comm);
 297     if( 1 == size )
 298         return MPI_SUCCESS;
 299     if( 2 != ompi_comm_size(comm) ) {
 300         return MPI_ERR_UNSUPPORTED_OPERATION;
 301     }
 302 
 303     remote = ompi_comm_rank(comm);
 304     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
 305                  "ompi_coll_base_barrier_intra_two_procs rank %d", remote));
 306 
 307     remote = (remote + 1) & 0x1;
 308 
 309     err = ompi_coll_base_sendrecv_zero(remote, MCA_COLL_BASE_TAG_BARRIER,
 310                                        remote, MCA_COLL_BASE_TAG_BARRIER,
 311                                        comm);
 312     return (err);
 313 }
 314 
 315 
 316 
 317 
 318 
 319 
 320 
 321 
 322 
 323 
 324 
 325 
 326 
 327 
 328 
 329 
 330 int ompi_coll_base_barrier_intra_basic_linear(struct ompi_communicator_t *comm,
 331                                               mca_coll_base_module_t *module)
 332 {
 333     int i, err, rank, size, line;
 334     ompi_request_t** requests = NULL;
 335 
 336     size = ompi_comm_size(comm);
 337     if( 1 == size )
 338         return MPI_SUCCESS;
 339     rank = ompi_comm_rank(comm);
 340 
 341     
 342     if (rank > 0) {
 343         err = MCA_PML_CALL(send (NULL, 0, MPI_BYTE, 0,
 344                                  MCA_COLL_BASE_TAG_BARRIER,
 345                                  MCA_PML_BASE_SEND_STANDARD, comm));
 346         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
 347 
 348         err = MCA_PML_CALL(recv (NULL, 0, MPI_BYTE, 0,
 349                                  MCA_COLL_BASE_TAG_BARRIER,
 350                                  comm, MPI_STATUS_IGNORE));
 351         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
 352     }
 353 
 354     
 355 
 356     else {
 357         requests = ompi_coll_base_comm_get_reqs(module->base_data, size);
 358         if( NULL == requests ) { err = OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto err_hndl; }
 359 
 360         for (i = 1; i < size; ++i) {
 361             err = MCA_PML_CALL(irecv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE,
 362                                      MCA_COLL_BASE_TAG_BARRIER, comm,
 363                                      &(requests[i])));
 364             if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
 365         }
 366         err = ompi_request_wait_all( size-1, requests+1, MPI_STATUSES_IGNORE );
 367         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
 368         requests = NULL;  
 369 
 370         for (i = 1; i < size; ++i) {
 371             err = MCA_PML_CALL(send(NULL, 0, MPI_BYTE, i,
 372                                     MCA_COLL_BASE_TAG_BARRIER,
 373                                     MCA_PML_BASE_SEND_STANDARD, comm));
 374             if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
 375         }
 376     }
 377 
 378     
 379     return MPI_SUCCESS;
 380  err_hndl:
 381     if( NULL != requests ) {
 382         
 383         if (MPI_ERR_IN_STATUS == err) {
 384             for( i = 0; i < size; i++ ) {
 385                 if (MPI_REQUEST_NULL == requests[i]) continue;
 386                 if (MPI_ERR_PENDING == requests[i]->req_status.MPI_ERROR) continue;
 387                 err = requests[i]->req_status.MPI_ERROR;
 388                 break;
 389             }
 390         }
 391         ompi_coll_base_free_reqs(requests, size);
 392     }
 393     OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
 394                   __FILE__, line, err, rank) );
 395     (void)line;  
 396     return err;
 397 }
 398 
 399 
 400 
 401 
 402 
 403 
 404 int ompi_coll_base_barrier_intra_tree(struct ompi_communicator_t *comm,
 405                                        mca_coll_base_module_t *module)
 406 {
 407     int rank, size, depth, err, jump, partner;
 408 
 409     size = ompi_comm_size(comm);
 410     if( 1 == size )
 411         return MPI_SUCCESS;
 412     rank = ompi_comm_rank(comm);
 413     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
 414                  "ompi_coll_base_barrier_intra_tree %d",
 415                  rank));
 416 
 417     
 418     depth = opal_next_poweroftwo_inclusive(size);
 419 
 420     for (jump=1; jump<depth; jump<<=1) {
 421         partner = rank ^ jump;
 422         if (!(partner & (jump-1)) && partner < size) {
 423             if (partner > rank) {
 424                 err = MCA_PML_CALL(recv (NULL, 0, MPI_BYTE, partner,
 425                                          MCA_COLL_BASE_TAG_BARRIER, comm,
 426                                          MPI_STATUS_IGNORE));
 427                 if (MPI_SUCCESS != err)
 428                     return err;
 429             } else if (partner < rank) {
 430                 err = MCA_PML_CALL(send (NULL, 0, MPI_BYTE, partner,
 431                                          MCA_COLL_BASE_TAG_BARRIER,
 432                                          MCA_PML_BASE_SEND_STANDARD, comm));
 433                 if (MPI_SUCCESS != err)
 434                     return err;
 435             }
 436         }
 437     }
 438 
 439     depth >>= 1;
 440     for (jump = depth; jump>0; jump>>=1) {
 441         partner = rank ^ jump;
 442         if (!(partner & (jump-1)) && partner < size) {
 443             if (partner > rank) {
 444                 err = MCA_PML_CALL(send (NULL, 0, MPI_BYTE, partner,
 445                                          MCA_COLL_BASE_TAG_BARRIER,
 446                                          MCA_PML_BASE_SEND_STANDARD, comm));
 447                 if (MPI_SUCCESS != err)
 448                     return err;
 449             } else if (partner < rank) {
 450                 err = MCA_PML_CALL(recv (NULL, 0, MPI_BYTE, partner,
 451                                          MCA_COLL_BASE_TAG_BARRIER, comm,
 452                                          MPI_STATUS_IGNORE));
 453                 if (MPI_SUCCESS != err)
 454                     return err;
 455             }
 456         }
 457     }
 458 
 459     return MPI_SUCCESS;
 460 }