ompi/mca/pml/crcpw/pml_crcpw

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mca_pml_crcpw_enable
mca_pml_crcpw_add_comm
mca_pml_crcpw_del_comm
mca_pml_crcpw_add_procs
mca_pml_crcpw_del_procs
mca_pml_crcpw_iprobe
mca_pml_crcpw_probe
mca_pml_crcpw_isend_init
mca_pml_crcpw_isend
mca_pml_crcpw_send
mca_pml_crcpw_irecv_init
mca_pml_crcpw_irecv
mca_pml_crcpw_recv
mca_pml_crcpw_dump
mca_pml_crcpw_progress
mca_pml_crcpw_start
mca_pml_crcpw_improbe
mca_pml_crcpw_mprobe
mca_pml_crcpw_imrecv
mca_pml_crcpw_mrecv
mca_pml_crcpw_ft_event
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2009 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2013 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2006 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2011      Sandia National Laboratories. All rights reserved.
  14  * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
  15  *                         reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 
  23 #include "ompi_config.h"
  24 
  25 #include <stdlib.h>
  26 #include <string.h>
  27 
  28 #include "opal/mca/btl/base/base.h"
  29 #include "ompi/mca/pml/pml.h"
  30 #include "ompi/mca/pml/crcpw/pml_crcpw.h"
  31 #include "ompi/mca/bml/base/base.h"
  32 
  33 #include "opal/class/opal_free_list.h"
  34 
  35 mca_pml_crcpw_module_t mca_pml_crcpw_module = {
  36     {
  37         mca_pml_crcpw_add_procs,
  38         mca_pml_crcpw_del_procs,
  39         mca_pml_crcpw_enable,
  40         mca_pml_crcpw_progress,
  41         mca_pml_crcpw_add_comm,
  42         mca_pml_crcpw_del_comm,
  43         mca_pml_crcpw_irecv_init,
  44         mca_pml_crcpw_irecv,
  45         mca_pml_crcpw_recv,
  46         mca_pml_crcpw_isend_init,
  47         mca_pml_crcpw_isend,
  48         mca_pml_crcpw_send,
  49         mca_pml_crcpw_iprobe,
  50         mca_pml_crcpw_probe,
  51         mca_pml_crcpw_start,
  52         mca_pml_crcpw_improbe,
  53         mca_pml_crcpw_mprobe,
  54         mca_pml_crcpw_imrecv,
  55         mca_pml_crcpw_mrecv,
  56         mca_pml_crcpw_dump,
  57         mca_pml_crcpw_ft_event,
  58 
  59         32768,
  60         INT_MAX
  61     }
  62 };
  63 
  64 #define PML_CRCP_STATE_ALLOC(pml_state)             \
  65 do {                                                \
  66   if( !pml_crcpw_is_finalized ) {                   \
  67       pml_state = (ompi_crcp_base_pml_state_t*)     \
  68         opal_free_list_wait (&pml_state_list);      \
  69   }                                                 \
  70 } while(0);
  71 
  72 #define PML_CRCP_STATE_RETURN(pml_state)    \
  73 do {                                        \
  74   if( !pml_crcpw_is_finalized ) {           \
  75     opal_free_list_return (&pml_state_list, \
  76     (opal_free_list_item_t*)pml_state);     \
  77   }                                         \
  78 } while(0);
  79 
  80 int mca_pml_crcpw_enable(bool enable)
  81 {
  82     int ret;
  83     ompi_crcp_base_pml_state_t * pml_state = NULL;
  84 
  85     if( OPAL_UNLIKELY(NULL == ompi_crcp.pml_enable) ) {
  86         return mca_pml_crcpw_module.wrapped_pml_module.pml_enable(enable);
  87     }
  88 
  89     PML_CRCP_STATE_ALLOC(pml_state);
  90 
  91     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
  92     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
  93 
  94     pml_state->state = OMPI_CRCP_PML_PRE;
  95     pml_state = ompi_crcp.pml_enable(enable, pml_state);
  96     if( OMPI_SUCCESS != pml_state->error_code) {
  97         ret =  pml_state->error_code;
  98         PML_CRCP_STATE_RETURN(pml_state);
  99         return ret;
 100     }
 101 
 102     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 103         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_enable(enable) ) ) {
 104             PML_CRCP_STATE_RETURN(pml_state);
 105             return ret;
 106         }
 107     }
 108 
 109     pml_state->state = OMPI_CRCP_PML_POST;
 110     pml_state = ompi_crcp.pml_enable(enable, pml_state);
 111     if( OMPI_SUCCESS != pml_state->error_code) {
 112         ret =  pml_state->error_code;
 113         PML_CRCP_STATE_RETURN(pml_state);
 114         return ret;
 115     }
 116 
 117     PML_CRCP_STATE_RETURN(pml_state);
 118 
 119     return OMPI_SUCCESS;
 120 }
 121 
 122 int mca_pml_crcpw_add_comm(ompi_communicator_t* comm)
 123 {
 124     int ret;
 125     ompi_crcp_base_pml_state_t * pml_state = NULL;
 126 
 127     if( OPAL_UNLIKELY(NULL == ompi_crcp.pml_add_comm) ) {
 128         return mca_pml_crcpw_module.wrapped_pml_module.pml_add_comm(comm);
 129     }
 130 
 131     PML_CRCP_STATE_ALLOC(pml_state);
 132 
 133     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 134     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 135 
 136     pml_state->state = OMPI_CRCP_PML_PRE;
 137     pml_state = ompi_crcp.pml_add_comm(comm, pml_state);
 138     if( OMPI_SUCCESS != pml_state->error_code) {
 139         ret =  pml_state->error_code;
 140         PML_CRCP_STATE_RETURN(pml_state);
 141         return ret;
 142     }
 143 
 144     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 145         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_add_comm(comm) ) ) {
 146             PML_CRCP_STATE_RETURN(pml_state);
 147             return ret;
 148         }
 149     }
 150 
 151     pml_state->state = OMPI_CRCP_PML_POST;
 152     pml_state = ompi_crcp.pml_add_comm(comm, pml_state);
 153     if( OMPI_SUCCESS != pml_state->error_code) {
 154         ret =  pml_state->error_code;
 155         PML_CRCP_STATE_RETURN(pml_state);
 156         return ret;
 157     }
 158 
 159     PML_CRCP_STATE_RETURN(pml_state);
 160 
 161     return OMPI_SUCCESS;
 162 }
 163 
 164 int mca_pml_crcpw_del_comm(ompi_communicator_t* comm)
 165 {
 166     int ret;
 167     ompi_crcp_base_pml_state_t * pml_state = NULL;
 168 
 169     if( OPAL_UNLIKELY(NULL == ompi_crcp.pml_del_comm) ) {
 170         return mca_pml_crcpw_module.wrapped_pml_module.pml_del_comm(comm);
 171     }
 172 
 173     PML_CRCP_STATE_ALLOC(pml_state);
 174     if( NULL == pml_state ) {
 175         return mca_pml_crcpw_module.wrapped_pml_module.pml_del_comm(comm);
 176     }
 177 
 178     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 179     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 180 
 181     pml_state->state = OMPI_CRCP_PML_PRE;
 182     pml_state = ompi_crcp.pml_del_comm(comm, pml_state);
 183     if( OMPI_SUCCESS != pml_state->error_code) {
 184         ret =  pml_state->error_code;
 185         PML_CRCP_STATE_RETURN(pml_state);
 186         return ret;
 187     }
 188 
 189     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 190         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_del_comm(comm) ) ) {
 191             PML_CRCP_STATE_RETURN(pml_state);
 192             return ret;
 193         }
 194     }
 195 
 196     pml_state->state = OMPI_CRCP_PML_POST;
 197     pml_state = ompi_crcp.pml_del_comm(comm, pml_state);
 198     if( OMPI_SUCCESS != pml_state->error_code) {
 199         ret =  pml_state->error_code;
 200         PML_CRCP_STATE_RETURN(pml_state);
 201         return ret;
 202     }
 203 
 204     PML_CRCP_STATE_RETURN(pml_state);
 205 
 206     return OMPI_SUCCESS;
 207 }
 208 
 209 int mca_pml_crcpw_add_procs(ompi_proc_t** procs, size_t nprocs)
 210 {
 211     int ret;
 212     ompi_crcp_base_pml_state_t * pml_state = NULL;
 213 
 214     PML_CRCP_STATE_ALLOC(pml_state);
 215 
 216     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 217     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 218 
 219     pml_state->state = OMPI_CRCP_PML_PRE;
 220     pml_state = ompi_crcp.pml_add_procs(procs, nprocs, pml_state);
 221     if( OMPI_SUCCESS != pml_state->error_code) {
 222         ret =  pml_state->error_code;
 223         PML_CRCP_STATE_RETURN(pml_state);
 224         return ret;
 225     }
 226 
 227     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 228         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_add_procs(procs, nprocs) ) ) {
 229             PML_CRCP_STATE_RETURN(pml_state);
 230             return ret;
 231         }
 232     }
 233 
 234     pml_state->state = OMPI_CRCP_PML_POST;
 235     pml_state = ompi_crcp.pml_add_procs(procs, nprocs, pml_state);
 236     if( OMPI_SUCCESS != pml_state->error_code) {
 237         ret =  pml_state->error_code;
 238         PML_CRCP_STATE_RETURN(pml_state);
 239         return ret;
 240     }
 241 
 242     PML_CRCP_STATE_RETURN(pml_state);
 243 
 244     return OMPI_SUCCESS;
 245 }
 246 
 247 int mca_pml_crcpw_del_procs(ompi_proc_t** procs, size_t nprocs)
 248 {
 249     int ret;
 250     ompi_crcp_base_pml_state_t * pml_state = NULL;
 251 
 252     PML_CRCP_STATE_ALLOC(pml_state);
 253 
 254     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 255     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 256 
 257     pml_state->state = OMPI_CRCP_PML_PRE;
 258     pml_state = ompi_crcp.pml_del_procs(procs, nprocs, pml_state);
 259     if( OMPI_SUCCESS != pml_state->error_code) {
 260         ret =  pml_state->error_code;
 261         PML_CRCP_STATE_RETURN(pml_state);
 262         return ret;
 263     }
 264 
 265     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 266         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_del_procs(procs, nprocs) ) ) {
 267             PML_CRCP_STATE_RETURN(pml_state);
 268             return ret;
 269         }
 270     }
 271 
 272     pml_state->state = OMPI_CRCP_PML_POST;
 273     pml_state = ompi_crcp.pml_del_procs(procs, nprocs, pml_state);
 274     if( OMPI_SUCCESS != pml_state->error_code) {
 275         ret =  pml_state->error_code;
 276         PML_CRCP_STATE_RETURN(pml_state);
 277         return ret;
 278     }
 279 
 280     PML_CRCP_STATE_RETURN(pml_state);
 281 
 282     return OMPI_SUCCESS;
 283 }
 284 
 285 int mca_pml_crcpw_iprobe(int dst, int tag, struct ompi_communicator_t* comm, int *matched, ompi_status_public_t* status )
 286 {
 287     int ret;
 288     ompi_crcp_base_pml_state_t * pml_state = NULL;
 289 
 290     PML_CRCP_STATE_ALLOC(pml_state);
 291 
 292     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 293     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 294 
 295     pml_state->state = OMPI_CRCP_PML_PRE;
 296     pml_state = ompi_crcp.pml_iprobe(dst, tag, comm, matched, status, pml_state);
 297     if( OMPI_SUCCESS != pml_state->error_code) {
 298         ret =  pml_state->error_code;
 299         PML_CRCP_STATE_RETURN(pml_state);
 300         return ret;
 301     }
 302 
 303     if( OMPI_CRCP_PML_DONE == pml_state->state) {
 304         goto CLEANUP;
 305     }
 306 
 307     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 308         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_iprobe(dst, tag, comm, matched, status) ) ) {
 309             PML_CRCP_STATE_RETURN(pml_state);
 310             return ret;
 311         }
 312     }
 313 
 314     pml_state->state = OMPI_CRCP_PML_POST;
 315     pml_state = ompi_crcp.pml_iprobe(dst, tag, comm, matched, status, pml_state);
 316     if( OMPI_SUCCESS != pml_state->error_code) {
 317         ret =  pml_state->error_code;
 318         PML_CRCP_STATE_RETURN(pml_state);
 319         return ret;
 320     }
 321 
 322  CLEANUP:
 323     PML_CRCP_STATE_RETURN(pml_state);
 324 
 325     return OMPI_SUCCESS;
 326 }
 327 
 328 int mca_pml_crcpw_probe( int dst, int tag, struct ompi_communicator_t* comm, ompi_status_public_t* status )
 329 {
 330     int ret;
 331     ompi_crcp_base_pml_state_t * pml_state = NULL;
 332 
 333     PML_CRCP_STATE_ALLOC(pml_state);
 334 
 335     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 336     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 337 
 338     pml_state->state = OMPI_CRCP_PML_PRE;
 339     pml_state = ompi_crcp.pml_probe(dst, tag, comm, status, pml_state);
 340     if( OMPI_SUCCESS != pml_state->error_code) {
 341         ret =  pml_state->error_code;
 342         PML_CRCP_STATE_RETURN(pml_state);
 343         return ret;
 344     }
 345 
 346     if( OMPI_CRCP_PML_DONE == pml_state->state) {
 347         goto CLEANUP;
 348     }
 349 
 350     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 351         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_probe(dst, tag, comm, status) ) ) {
 352             PML_CRCP_STATE_RETURN(pml_state);
 353             return ret;
 354         }
 355     }
 356 
 357     pml_state->state = OMPI_CRCP_PML_POST;
 358     pml_state = ompi_crcp.pml_probe(dst, tag, comm, status, pml_state);
 359     if( OMPI_SUCCESS != pml_state->error_code) {
 360         ret =  pml_state->error_code;
 361         PML_CRCP_STATE_RETURN(pml_state);
 362         return ret;
 363     }
 364 
 365  CLEANUP:
 366     PML_CRCP_STATE_RETURN(pml_state);
 367 
 368     return OMPI_SUCCESS;
 369 }
 370 
 371 int mca_pml_crcpw_isend_init( void *buf, size_t count, ompi_datatype_t *datatype, int dst, int tag,
 372                               mca_pml_base_send_mode_t mode, struct ompi_communicator_t* comm, struct ompi_request_t **request )
 373 {
 374     int ret;
 375     ompi_crcp_base_pml_state_t * pml_state = NULL;
 376 
 377     PML_CRCP_STATE_ALLOC(pml_state);
 378 
 379     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 380     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 381 
 382     pml_state->state = OMPI_CRCP_PML_PRE;
 383     pml_state = ompi_crcp.pml_isend_init(buf, count, datatype, dst, tag, mode, comm, request, pml_state);
 384     if( OMPI_SUCCESS != pml_state->error_code) {
 385         ret =  pml_state->error_code;
 386         PML_CRCP_STATE_RETURN(pml_state);
 387         return ret;
 388     }
 389 
 390     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 391         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_isend_init(buf, count, datatype, dst, tag, mode, comm, request) ) ) {
 392             PML_CRCP_STATE_RETURN(pml_state);
 393             return ret;
 394         }
 395     }
 396 
 397     pml_state->state = OMPI_CRCP_PML_POST;
 398     pml_state = ompi_crcp.pml_isend_init(buf, count, datatype, dst, tag, mode, comm, request, pml_state);
 399     if( OMPI_SUCCESS != pml_state->error_code) {
 400         ret =  pml_state->error_code;
 401         PML_CRCP_STATE_RETURN(pml_state);
 402         return ret;
 403     }
 404 
 405     PML_CRCP_STATE_RETURN(pml_state);
 406 
 407     return OMPI_SUCCESS;
 408 }
 409 
 410 int mca_pml_crcpw_isend( void *buf, size_t count, ompi_datatype_t *datatype, int dst, int tag,
 411                          mca_pml_base_send_mode_t mode, struct ompi_communicator_t* comm, struct ompi_request_t **request )
 412 {
 413     int ret;
 414     ompi_crcp_base_pml_state_t * pml_state = NULL;
 415 
 416     PML_CRCP_STATE_ALLOC(pml_state);
 417 
 418     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 419     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 420 
 421     pml_state->state = OMPI_CRCP_PML_PRE;
 422     pml_state = ompi_crcp.pml_isend(buf, count, datatype, dst, tag, mode, comm, request, pml_state);
 423     if( OMPI_SUCCESS != pml_state->error_code) {
 424         ret =  pml_state->error_code;
 425         PML_CRCP_STATE_RETURN(pml_state);
 426         return ret;
 427     }
 428 
 429     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 430         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_isend(buf, count, datatype, dst, tag, mode, comm, request) ) ) {
 431             PML_CRCP_STATE_RETURN(pml_state);
 432             return ret;
 433         }
 434     }
 435 
 436     pml_state->state = OMPI_CRCP_PML_POST;
 437     pml_state = ompi_crcp.pml_isend(buf, count, datatype, dst, tag, mode, comm, request, pml_state);
 438     if( OMPI_SUCCESS != pml_state->error_code) {
 439         ret =  pml_state->error_code;
 440         PML_CRCP_STATE_RETURN(pml_state);
 441         return ret;
 442     }
 443 
 444     PML_CRCP_STATE_RETURN(pml_state);
 445 
 446     opal_cr_stall_check = false;
 447     OPAL_CR_TEST_CHECKPOINT_READY();
 448 
 449     return OMPI_SUCCESS;
 450 }
 451 
 452 int mca_pml_crcpw_send(  void *buf, size_t count, ompi_datatype_t *datatype, int dst, int tag,
 453                          mca_pml_base_send_mode_t mode, struct ompi_communicator_t* comm )
 454 {
 455     int ret;
 456     ompi_crcp_base_pml_state_t * pml_state = NULL;
 457 
 458     PML_CRCP_STATE_ALLOC(pml_state);
 459 
 460     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 461     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 462 
 463     pml_state->state = OMPI_CRCP_PML_PRE;
 464     pml_state = ompi_crcp.pml_send(buf, count, datatype, dst, tag, mode, comm, pml_state);
 465     if( OMPI_SUCCESS != pml_state->error_code) {
 466         ret =  pml_state->error_code;
 467         PML_CRCP_STATE_RETURN(pml_state);
 468         return ret;
 469     }
 470 
 471     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 472         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_send(buf, count, datatype, dst, tag, mode, comm) ) ) {
 473             PML_CRCP_STATE_RETURN(pml_state);
 474             return ret;
 475         }
 476     }
 477 
 478     pml_state->state = OMPI_CRCP_PML_POST;
 479     pml_state = ompi_crcp.pml_send(buf, count, datatype, dst, tag, mode, comm, pml_state);
 480     if( OMPI_SUCCESS != pml_state->error_code) {
 481         ret =  pml_state->error_code;
 482         PML_CRCP_STATE_RETURN(pml_state);
 483         return ret;
 484     }
 485 
 486     PML_CRCP_STATE_RETURN(pml_state);
 487 
 488     opal_cr_stall_check = false;
 489     OPAL_CR_TEST_CHECKPOINT_READY();
 490 
 491     return OMPI_SUCCESS;
 492 }
 493 
 494 int mca_pml_crcpw_irecv_init( void *buf, size_t count, ompi_datatype_t *datatype, int src, int tag,
 495                               struct ompi_communicator_t* comm,  struct ompi_request_t **request)
 496 {
 497     int ret;
 498     ompi_crcp_base_pml_state_t * pml_state = NULL;
 499 
 500     PML_CRCP_STATE_ALLOC(pml_state);
 501 
 502     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 503     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 504 
 505     pml_state->state = OMPI_CRCP_PML_PRE;
 506     pml_state = ompi_crcp.pml_irecv_init(buf, count, datatype, src, tag, comm, request,  pml_state);
 507     if( OMPI_SUCCESS != pml_state->error_code) {
 508         ret =  pml_state->error_code;
 509         PML_CRCP_STATE_RETURN(pml_state);
 510         return ret;
 511     }
 512 
 513     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 514         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_irecv_init(buf, count, datatype, src, tag, comm, request) ) ) {
 515             PML_CRCP_STATE_RETURN(pml_state);
 516             return ret;
 517         }
 518     }
 519 
 520     pml_state->state = OMPI_CRCP_PML_POST;
 521     pml_state = ompi_crcp.pml_irecv_init(buf, count, datatype, src, tag, comm, request,  pml_state);
 522     if( OMPI_SUCCESS != pml_state->error_code) {
 523         ret =  pml_state->error_code;
 524         PML_CRCP_STATE_RETURN(pml_state);
 525         return ret;
 526     }
 527 
 528     PML_CRCP_STATE_RETURN(pml_state);
 529 
 530     return OMPI_SUCCESS;
 531 }
 532 
 533 int mca_pml_crcpw_irecv( void *buf, size_t count, ompi_datatype_t *datatype, int src, int tag,
 534                          struct ompi_communicator_t* comm, struct ompi_request_t **request )
 535 {
 536     int ret;
 537     ompi_crcp_base_pml_state_t * pml_state = NULL;
 538 
 539     PML_CRCP_STATE_ALLOC(pml_state);
 540 
 541     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 542     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 543 
 544     pml_state->state = OMPI_CRCP_PML_PRE;
 545     pml_state = ompi_crcp.pml_irecv(buf, count, datatype, src, tag, comm, request, pml_state);
 546     if( OMPI_SUCCESS != pml_state->error_code) {
 547         ret =  pml_state->error_code;
 548         PML_CRCP_STATE_RETURN(pml_state);
 549         return ret;
 550     }
 551 
 552     if( OMPI_CRCP_PML_DONE == pml_state->state) {
 553         goto CLEANUP;
 554     }
 555 
 556     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 557         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_irecv(buf, count, datatype, src, tag, comm, request) ) ) {
 558             PML_CRCP_STATE_RETURN(pml_state);
 559             return ret;
 560         }
 561     }
 562 
 563     pml_state->state = OMPI_CRCP_PML_POST;
 564     pml_state = ompi_crcp.pml_irecv(buf, count, datatype, src, tag, comm, request, pml_state);
 565     if( OMPI_SUCCESS != pml_state->error_code) {
 566         ret =  pml_state->error_code;
 567         PML_CRCP_STATE_RETURN(pml_state);
 568         return ret;
 569     }
 570 
 571  CLEANUP:
 572     PML_CRCP_STATE_RETURN(pml_state);
 573 
 574     return OMPI_SUCCESS;
 575 }
 576 
 577 int mca_pml_crcpw_recv(  void *buf, size_t count, ompi_datatype_t *datatype, int src, int tag,
 578                          struct ompi_communicator_t* comm,  ompi_status_public_t* given_status)
 579 {
 580     int ret = OMPI_SUCCESS, actual_ret = OMPI_SUCCESS;
 581     ompi_status_public_t* status = NULL;
 582     ompi_crcp_base_pml_state_t * pml_state = NULL;
 583 
 584     PML_CRCP_STATE_ALLOC(pml_state);
 585 
 586     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 587     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 588 
 589     if( given_status == NULL) {
 590         status = (ompi_status_public_t*)malloc(sizeof(ompi_status_public_t));
 591     }
 592     else {
 593         status = given_status;
 594     }
 595 
 596     pml_state->state = OMPI_CRCP_PML_PRE;
 597     pml_state = ompi_crcp.pml_recv(buf, count, datatype, src, tag, comm, status, pml_state);
 598     if( OMPI_SUCCESS != pml_state->error_code) {
 599         ret =  pml_state->error_code;
 600         PML_CRCP_STATE_RETURN(pml_state);
 601         return ret;
 602     }
 603 
 604     if( OMPI_CRCP_PML_DONE == pml_state->state) {
 605         goto CLEANUP;
 606     }
 607 
 608     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 609         if( OMPI_SUCCESS != (actual_ret = mca_pml_crcpw_module.wrapped_pml_module.pml_recv(buf, count, datatype, src, tag, comm, status) ) ) {
 610             PML_CRCP_STATE_RETURN(pml_state);
 611             return ret;
 612         }
 613     }
 614 
 615     pml_state->state = OMPI_CRCP_PML_POST;
 616     pml_state = ompi_crcp.pml_recv(buf, count, datatype, src, tag, comm, status, pml_state);
 617     if( OMPI_SUCCESS != pml_state->error_code) {
 618         ret =  pml_state->error_code;
 619         PML_CRCP_STATE_RETURN(pml_state);
 620         return ret;
 621     }
 622 
 623     if( given_status == NULL) {
 624         free(status);
 625     }
 626 
 627  CLEANUP:
 628     PML_CRCP_STATE_RETURN(pml_state);
 629 
 630     opal_cr_stall_check = false;
 631     OPAL_CR_TEST_CHECKPOINT_READY();
 632 
 633     return actual_ret;
 634 }
 635 
 636 int mca_pml_crcpw_dump( struct ompi_communicator_t* comm, int verbose )
 637 {
 638     int ret;
 639     ompi_crcp_base_pml_state_t * pml_state = NULL;
 640 
 641     PML_CRCP_STATE_ALLOC(pml_state);
 642 
 643     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 644     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 645 
 646     pml_state->state = OMPI_CRCP_PML_PRE;
 647     pml_state = ompi_crcp.pml_dump(comm, verbose, pml_state);
 648     if( OMPI_SUCCESS != pml_state->error_code) {
 649         ret =  pml_state->error_code;
 650         PML_CRCP_STATE_RETURN(pml_state);
 651         return ret;
 652     }
 653 
 654     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 655         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_dump(comm, verbose) ) ) {
 656             PML_CRCP_STATE_RETURN(pml_state);
 657             return ret;
 658         }
 659     }
 660 
 661     pml_state->state = OMPI_CRCP_PML_POST;
 662     pml_state = ompi_crcp.pml_dump(comm, verbose, pml_state);
 663     if( OMPI_SUCCESS != pml_state->error_code) {
 664         ret =  pml_state->error_code;
 665         PML_CRCP_STATE_RETURN(pml_state);
 666         return ret;
 667     }
 668 
 669     PML_CRCP_STATE_RETURN(pml_state);
 670 
 671     return OMPI_SUCCESS;
 672 }
 673 
 674 int mca_pml_crcpw_progress(void)
 675 {
 676     int ret;
 677     ompi_crcp_base_pml_state_t * pml_state = NULL;
 678 
 679     if( OPAL_LIKELY(NULL == ompi_crcp.pml_progress) ) {
 680         return mca_pml_crcpw_module.wrapped_pml_module.pml_progress();
 681     }
 682 
 683     PML_CRCP_STATE_ALLOC(pml_state);
 684 
 685     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 686     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 687 
 688     pml_state->state = OMPI_CRCP_PML_PRE;
 689     pml_state = ompi_crcp.pml_progress(pml_state);
 690     if( OMPI_SUCCESS != pml_state->error_code) {
 691         ret =  pml_state->error_code;
 692         PML_CRCP_STATE_RETURN(pml_state);
 693         return ret;
 694     }
 695 
 696     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 697         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_progress() ) ) {
 698             PML_CRCP_STATE_RETURN(pml_state);
 699             return ret;
 700         }
 701     }
 702 
 703     pml_state->state = OMPI_CRCP_PML_POST;
 704     pml_state = ompi_crcp.pml_progress(pml_state);
 705     if( OMPI_SUCCESS != pml_state->error_code) {
 706         ret =  pml_state->error_code;
 707         PML_CRCP_STATE_RETURN(pml_state);
 708         return ret;
 709     }
 710 
 711     PML_CRCP_STATE_RETURN(pml_state);
 712 
 713     return OMPI_SUCCESS;
 714 }
 715 
 716 int mca_pml_crcpw_start( size_t count, ompi_request_t** requests )
 717 {
 718     int ret;
 719     ompi_crcp_base_pml_state_t * pml_state = NULL;
 720 
 721     PML_CRCP_STATE_ALLOC(pml_state);
 722 
 723     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 724     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 725 
 726     pml_state->state = OMPI_CRCP_PML_PRE;
 727     pml_state = ompi_crcp.pml_start(count, requests, pml_state);
 728     if( OMPI_SUCCESS != pml_state->error_code) {
 729         ret =  pml_state->error_code;
 730         PML_CRCP_STATE_RETURN(pml_state);
 731         return ret;
 732     }
 733 
 734     if( OMPI_CRCP_PML_DONE == pml_state->state) {
 735         goto CLEANUP;
 736     }
 737 
 738     if( OMPI_CRCP_PML_SKIP != pml_state->state) {
 739         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_start(count, requests) ) ) {
 740             PML_CRCP_STATE_RETURN(pml_state);
 741             return ret;
 742         }
 743     }
 744 
 745     pml_state->state = OMPI_CRCP_PML_POST;
 746     pml_state = ompi_crcp.pml_start(count, requests, pml_state);
 747     if( OMPI_SUCCESS != pml_state->error_code) {
 748         ret =  pml_state->error_code;
 749         PML_CRCP_STATE_RETURN(pml_state);
 750         return ret;
 751     }
 752 
 753  CLEANUP:
 754     PML_CRCP_STATE_RETURN(pml_state);
 755 
 756     return OMPI_SUCCESS;
 757 }
 758 
 759 
 760 int
 761 mca_pml_crcpw_improbe(int dst,
 762                       int tag,
 763                       struct ompi_communicator_t* comm,
 764                       int *matched,
 765                       struct ompi_message_t **message,
 766                       ompi_status_public_t* status)
 767 {
 768     return OMPI_ERR_NOT_SUPPORTED;
 769 }
 770 
 771 
 772 int
 773 mca_pml_crcpw_mprobe(int dst,
 774                      int tag,
 775                      struct ompi_communicator_t* comm,
 776                      struct ompi_message_t **message,
 777                      ompi_status_public_t* status)
 778 {
 779     return OMPI_ERR_NOT_SUPPORTED;
 780 }
 781 
 782 
 783 int
 784 mca_pml_crcpw_imrecv(void *buf,
 785                      size_t count,
 786                      ompi_datatype_t *datatype,
 787                      struct ompi_message_t **message,
 788                      struct ompi_request_t **request)
 789 {
 790     return OMPI_ERR_NOT_SUPPORTED;
 791 }
 792 
 793 
 794 int
 795 mca_pml_crcpw_mrecv(void *buf,
 796                     size_t count,
 797                     ompi_datatype_t *datatype,
 798                     struct ompi_message_t **message,
 799                     ompi_status_public_t* status)
 800 {
 801     return OMPI_ERR_NOT_SUPPORTED;
 802 }
 803 
 804 
 805 int mca_pml_crcpw_ft_event(int state)
 806 {
 807     int ret;
 808     ompi_crcp_base_pml_state_t * pml_state = NULL;
 809 
 810     PML_CRCP_STATE_ALLOC(pml_state);
 811 
 812     pml_state->wrapped_pml_component = &(mca_pml_crcpw_module.wrapped_pml_component);
 813     pml_state->wrapped_pml_module    = &(mca_pml_crcpw_module.wrapped_pml_module);
 814 
 815     pml_state->state = OMPI_CRCP_PML_PRE;
 816     pml_state = ompi_crcp.pml_ft_event(state, pml_state);
 817     if( OMPI_SUCCESS != pml_state->error_code) {
 818         ret =  pml_state->error_code;
 819         PML_CRCP_STATE_RETURN(pml_state);
 820         return ret;
 821     }
 822 
 823     if( OMPI_CRCP_PML_SKIP != pml_state->state &&
 824         NULL != mca_pml_crcpw_module.wrapped_pml_module.pml_ft_event) {
 825         if( OMPI_SUCCESS != (ret = mca_pml_crcpw_module.wrapped_pml_module.pml_ft_event(state) ) ) {
 826             PML_CRCP_STATE_RETURN(pml_state);
 827             return ret;
 828         }
 829     }
 830 
 831     pml_state->state = OMPI_CRCP_PML_POST;
 832     pml_state = ompi_crcp.pml_ft_event(state, pml_state);
 833     if( OMPI_SUCCESS != pml_state->error_code) {
 834         ret =  pml_state->error_code;
 835         PML_CRCP_STATE_RETURN(pml_state);
 836         return ret;
 837     }
 838 
 839     PML_CRCP_STATE_RETURN(pml_state);
 840 
 841     return OMPI_SUCCESS;
 842 }
/* [<][>][^][v][top][bottom][index][help] */
root/ompi/mca/pml/crcpw/pml_crcpw_module.c

DEFINITIONS
