root/ompi/mca/vprotocol/pessimist/vprotocol_pessimist_wait.c

DEFINITIONS

1. vprotocol_pessimist_request_no_free
2. mca_vprotocol_pessimist_test
3. mca_vprotocol_pessimist_test_all
4. mca_vprotocol_pessimist_test_any
5. mca_vprotocol_pessimist_wait_any
6. mca_vprotocol_pessimist_test_some
7. mca_vprotocol_pessimist_wait_some

   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of the University of Tennessee.
   3  *                         All rights reserved.
   4  * $COPYRIGHT$
   5  *
   6  * Additional copyrights may follow
   7  *
   8  * $HEADER$
   9  */
  10 
  11 #include "ompi_config.h"
  12 #include "vprotocol_pessimist.h"
  13 #include "vprotocol_pessimist_wait.h"
  14 
  15 
  16 /* Helpers to prevent requests from being freed by the real wait/test */
  17 static int vprotocol_pessimist_request_no_free(ompi_request_t **req) {
  18     return OMPI_SUCCESS;
  19 }
  20 
  21 #define PREPARE_REQUESTS_WITH_NO_FREE(count, requests) do { \
  22     size_t i; \
  23     for(i = 0; i < count; i++) \
  24     { \
  25         if(requests[i] == MPI_REQUEST_NULL) continue; \
  26         requests[i]->req_free = vprotocol_pessimist_request_no_free; \
  27     } \
  28 } while(0)
  29 
  30 
  31 int mca_vprotocol_pessimist_test(ompi_request_t ** rptr, int *completed,
  32                                  ompi_status_public_t * status)
  33 {
  34     int ret;
  35     int index;
  36 
  37     VPROTOCOL_PESSIMIST_DELIVERY_REPLAY(1, rptr, completed, &index, status);
  38 
  39     ret = mca_pml_v.host_request_fns.req_test(rptr, completed, status);
  40     if(completed)
  41         vprotocol_pessimist_delivery_log(*rptr);
  42     else
  43         vprotocol_pessimist_delivery_log(NULL);
  44     return ret;
  45 }
  46 
  47 int mca_vprotocol_pessimist_test_all(size_t count, ompi_request_t ** requests,
  48                                      int *completed,
  49                                      ompi_status_public_t * statuses)
  50 {
  51     int ret;
  52     int index;
  53 
  54     /* /!\ this is not correct until I upgrade DELIVERY_REPLAY to manage several requests at once */
  55     VPROTOCOL_PESSIMIST_DELIVERY_REPLAY(1, requests, completed, &index, statuses);
  56 
  57     ret = mca_pml_v.host_request_fns.req_test_all(count, requests, completed,
  58                                                    statuses);
  59 #if 0
  60 /* This is not correct :/ */
  61     if(completed)
  62         vprotocol_pessimist_delivery_log(requests); /* /!\ need to make sure this is correct: what if first is request_null ? */
  63     else
  64         vprotocol_pessimist_delivery_log(NULL);
  65 #endif
  66     return ret;
  67 }
  68 
  69 
  70 /* TESTANY and WAITANY */
  71 
  72 int mca_vprotocol_pessimist_test_any(size_t count, ompi_request_t ** requests,
  73                                      int *index, int *completed,
  74                                      ompi_status_public_t * status)
  75 {
  76     int ret;
  77     size_t i;
  78 
  79     VPROTOCOL_PESSIMIST_DELIVERY_REPLAY(count, requests, completed, index, status);
  80 
  81     PREPARE_REQUESTS_WITH_NO_FREE(count, requests);
  82 
  83     /* Call the real one to do the job */
  84     ret = mca_pml_v.host_request_fns.req_test_any(count, requests, index, completed,
  85                                                   status);
  86 
  87     if(completed)
  88     {   /* Parse the result */
  89         for(i = 0; i < count; i++)
  90         {
  91             ompi_request_t *req = requests[i];
  92             if(req == MPI_REQUEST_NULL) continue;
  93 
  94             /* Restore requests and store they've been delivered */
  95             req->req_free = mca_vprotocol_pessimist_request_free;
  96             if(i == (size_t) *index)
  97             {
  98                 vprotocol_pessimist_delivery_log(req);
  99                 /* only free request without error status */
 100                 if(req->req_status.MPI_ERROR == MPI_SUCCESS)
 101                     ompi_request_free(&(requests[i]));
 102                 else
 103                     ret = req->req_status.MPI_ERROR;
 104             }
 105         }
 106     }
 107     else
 108     {
 109         /* No request delivered this time, log it */
 110         vprotocol_pessimist_delivery_log(NULL);
 111     }
 112     return ret;
 113 }
 114 
 115 int mca_vprotocol_pessimist_wait_any(size_t count, ompi_request_t ** requests,
 116                                      int *index, ompi_status_public_t * status)
 117 {
 118     int ret;
 119     size_t i;
 120     int dummy;
 121 
 122     VPROTOCOL_PESSIMIST_DELIVERY_REPLAY(count, requests, &dummy, index, status);
 123 
 124     PREPARE_REQUESTS_WITH_NO_FREE(count, requests);
 125 
 126     /* Call the real one to do the job */
 127     ret = mca_pml_v.host_request_fns.req_wait_any(count, requests, index, status);
 128 
 129     /* Parse the result */
 130     for(i = 0; i < count; i++)
 131     {
 132         ompi_request_t *req = requests[i];
 133         if(req == MPI_REQUEST_NULL) continue;
 134 
 135         /* Restore requests and store they've been delivered */
 136         req->req_free = mca_vprotocol_pessimist_request_free;
 137         if(i == (size_t) *index)
 138         {
 139             vprotocol_pessimist_delivery_log(req);
 140             /* only free request without error status */
 141             if(req->req_status.MPI_ERROR == MPI_SUCCESS)
 142                 ompi_request_free(&(requests[i]));
 143             else
 144                 ret = req->req_status.MPI_ERROR;
 145         }
 146     }
 147     return ret;
 148 }
 149 
 150 
 151 /* TESTSOME and WAITSOME */
 152 
 153 int mca_vprotocol_pessimist_test_some(size_t count, ompi_request_t ** requests,
 154                                       int * outcount, int * indices,
 155                                       ompi_status_public_t * statuses)
 156 {
 157     int ret;
 158     ret = mca_vprotocol_pessimist_test_any(count, requests, indices, outcount, statuses);
 159     if(*outcount) *outcount = 1;
 160     return ret;
 161 }
 162 
 163 int mca_vprotocol_pessimist_wait_some(size_t count, ompi_request_t ** requests,
 164                                       int *outcount, int *indexes,
 165                                       ompi_status_public_t * statuses)
 166 {
 167     int ret;
 168     ret = mca_vprotocol_pessimist_wait_any(count, requests, indexes, statuses);
 169     if(MPI_UNDEFINED == *indexes) *outcount = 0;
 170     else *outcount = 1;
 171     return ret;
 172 }