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 };