1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 class Request {
  23 #if 0 
  24   
  25 #endif
  26 public:
  27 #if 0 
  28 
  29   
  30   Request() { }
  31   Request(MPI_Request i) : pmpi_request(i) { }
  32 
  33   
  34   Request(const Request& r) : pmpi_request(r.pmpi_request) { }
  35 
  36   Request(const PMPI::Request& r) : pmpi_request(r) { }
  37 
  38   virtual ~Request() {}
  39 
  40   Request& operator=(const Request& r) {
  41     pmpi_request = r.pmpi_request; return *this; }
  42 
  43   
  44   bool operator== (const Request &a)
  45   { return (bool)(pmpi_request == a.pmpi_request); }
  46   bool operator!= (const Request &a)
  47   { return (bool)!(*this == a); }
  48 
  49   
  50   Request& operator= (const MPI_Request &i) {
  51     pmpi_request = i; return *this;  }
  52 
  53   operator MPI_Request () const { return pmpi_request; }
  54   
  55   operator const PMPI::Request&() const { return pmpi_request; }
  56 
  57 #else
  58 
  59   
  60   Request() : mpi_request(MPI_REQUEST_NULL) { }
  61   virtual ~Request() {}
  62   Request(MPI_Request i) : mpi_request(i) { }
  63 
  64   
  65   Request(const Request& r) : mpi_request(r.mpi_request) { }
  66 
  67   Request& operator=(const Request& r) {
  68     mpi_request = r.mpi_request; return *this; }
  69 
  70   
  71   bool operator== (const Request &a)
  72   { return (bool)(mpi_request == a.mpi_request); }
  73   bool operator!= (const Request &a)
  74   { return (bool)!(*this == a); }
  75 
  76   
  77   Request& operator= (const MPI_Request &i) {
  78     mpi_request = i; return *this; }
  79   operator MPI_Request () const { return mpi_request; }
  80   
  81 
  82 #endif
  83 
  84   
  85   
  86   
  87 
  88   virtual void Wait(Status &status);
  89 
  90   virtual void Wait();
  91 
  92   virtual bool Test(Status &status);
  93 
  94   virtual bool Test();
  95 
  96   virtual void Free(void);
  97 
  98   static int Waitany(int count, Request array[], Status& status);
  99 
 100   static int Waitany(int count, Request array[]);
 101 
 102   static bool Testany(int count, Request array[], int& index, Status& status);
 103 
 104   static bool Testany(int count, Request array[], int& index);
 105 
 106   static void Waitall(int count, Request req_array[], Status stat_array[]);
 107 
 108   static void Waitall(int count, Request req_array[]);
 109 
 110   static bool Testall(int count, Request req_array[], Status stat_array[]);
 111 
 112   static bool Testall(int count, Request req_array[]);
 113 
 114   static int Waitsome(int incount, Request req_array[],
 115                              int array_of_indices[], Status stat_array[]) ;
 116 
 117   static int Waitsome(int incount, Request req_array[],
 118                              int array_of_indices[]);
 119 
 120   static int Testsome(int incount, Request req_array[],
 121                              int array_of_indices[], Status stat_array[]);
 122 
 123   static int Testsome(int incount, Request req_array[],
 124                              int array_of_indices[]);
 125 
 126   virtual void Cancel(void) const;
 127 
 128   virtual bool Get_status(Status& status) const;
 129 
 130   virtual bool Get_status() const;
 131 
 132 protected:
 133 #if ! 0 
 134   MPI_Request mpi_request;
 135 #endif
 136 
 137 private:
 138 
 139 #if 0 
 140   PMPI::Request pmpi_request;
 141 #endif
 142 
 143 };
 144 
 145 
 146 class Prequest : public Request {
 147 #if 0 
 148   
 149 #endif
 150 public:
 151 
 152   Prequest() { }
 153 
 154 #if 0 
 155   Prequest(const Request& p) : Request(p), pmpi_request(p) { }
 156 
 157   Prequest(const PMPI::Prequest& r) :
 158     Request((const PMPI::Request&)r),
 159     pmpi_request(r) { }
 160 
 161   Prequest(const MPI_Request &i) : Request(i), pmpi_request(i) { }
 162 
 163   virtual ~Prequest() { }
 164 
 165   Prequest& operator=(const Request& r) {
 166     Request::operator=(r);
 167     pmpi_request = (PMPI::Prequest)r; return *this; }
 168 
 169   Prequest& operator=(const Prequest& r) {
 170     Request::operator=(r);
 171     pmpi_request = r.pmpi_request; return *this; }
 172 #else
 173   Prequest(const Request& p) : Request(p) { }
 174 
 175   Prequest(const MPI_Request &i) : Request(i) { }
 176 
 177   virtual ~Prequest() { }
 178 
 179   Prequest& operator=(const Request& r) {
 180     mpi_request = r; return *this; }
 181 
 182   Prequest& operator=(const Prequest& r) {
 183     mpi_request = r.mpi_request; return *this; }
 184 #endif
 185 
 186   virtual void Start();
 187 
 188   static void Startall(int count, Prequest array_of_requests[]);
 189 
 190 #if 0 
 191 private:
 192   PMPI::Prequest pmpi_request;
 193 #endif
 194 };
 195 
 196 
 197 
 198 
 199 
 200 class Grequest : public MPI::Request {
 201   public:
 202     typedef int Query_function(void *, Status&);
 203     typedef int Free_function(void *);
 204     typedef int Cancel_function(void *, bool);
 205 
 206     Grequest() {}
 207     Grequest(const Request& req) : Request(req) {}
 208     Grequest(const MPI_Request &req) : Request(req) {}
 209     virtual ~Grequest() {}
 210 
 211     Grequest& operator=(const Request& req) {
 212         mpi_request = req; return(*this);
 213     }
 214 
 215     Grequest& operator=(const Grequest& req) {
 216         mpi_request = req.mpi_request; return(*this);
 217     }
 218 
 219     static Grequest Start(Query_function *, Free_function *,
 220             Cancel_function *, void *);
 221 
 222     virtual void Complete();
 223 
 224     
 225     
 226     
 227     
 228     
 229     struct Intercept_data_t {
 230         void *id_extra;
 231         Grequest::Query_function *id_cxx_query_fn;
 232         Grequest::Free_function *id_cxx_free_fn;
 233         Grequest::Cancel_function *id_cxx_cancel_fn;
 234     };
 235 };