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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
#ifndef GDATA_HH
#define GDATA_HH
#include <cassert>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <string>
#include <vector>
#include "cctk.h"
#include "commstate.hh"
#include "defs.hh"
#include "dist.hh"
#include "bbox.hh"
#include "operators.hh"
#include "timestat.hh"
#include "vect.hh"
using namespace std;
// A generic data storage without type information
class gdata {
protected: // should be readonly
// Fields
const int varindex; // Cactus variable index, or -1
centering cent;
operator_type transport_operator;
bool _has_storage; // has storage associated (on some processor)
int _size; // size
int _proc; // stored on processor
ivect _shape, _stride; // shape and index order
ibbox _extent; // bbox for all data
bool comm_active; // a communication is going on
MPI_Request request; // outstanding MPI request
int tag; // MPI tag for this object
private:
// Forbid copying and passing by value
gdata (gdata const &);
gdata & operator= (gdata const &);
public:
// Constructors
gdata (const int varindex,
const centering cent = error_centered,
const operator_type transport_operator = op_error,
const int tag = -1);
// Destructors
virtual ~gdata ();
// Pseudo constructors
virtual gdata*
make_typed (const int varindex,
const centering cent = error_centered,
const operator_type transport_operator = op_error,
const int tag = -1) const = 0;
// Processor management
void change_processor (comm_state& state,
const int newproc,
void* const mem=0);
protected:
virtual void change_processor_recv (comm_state& state,
const int newproc,
void* const mem=0)
= 0;
virtual void change_processor_send (comm_state& state,
const int newproc,
void* const mem=0)
= 0;
virtual void change_processor_wait (comm_state& state,
const int newproc,
void* const mem=0)
= 0;
public:
// Storage management
virtual void allocate (const ibbox& extent, const int proc,
void* const mem=0) = 0;
virtual void free () = 0;
// Accessors
bool has_storage () const {
return _has_storage;
}
virtual const void* storage () const = 0;
virtual void* storage () = 0;
int size () const {
assert (_has_storage);
return _size;
}
int proc () const {
assert (_has_storage);
return _proc;
}
const ivect& shape () const {
assert (_has_storage);
return _shape;
}
const ivect& stride () const {
assert (_has_storage);
return _stride;
}
const ibbox& extent () const {
assert (_has_storage);
return _extent;
}
// Data accessors
int offset (const ivect& index) const {
assert (_has_storage);
assert (all((index-extent().lower()) % extent().stride() == 0));
ivect ind = (index-extent().lower()) / extent().stride();
assert (all(ind>=0 && ind<=shape()));
return dot(ind, stride());
}
private:
// Datatype accessors
// maps the C datatype of a data class object to a 0-based index
virtual unsigned int c_datatype () const = 0;
// Data manipulators
private:
virtual comm_state::gcommbuf *
make_typed_commbuf (const ibbox & box)
const = 0;
public:
void copy_from (comm_state& state,
const gdata* src, const ibbox& box);
void interpolate_from (comm_state& state,
const vector<const gdata*> srcs,
const vector<CCTK_REAL> times,
const ibbox& box,
const CCTK_REAL time,
const int order_space,
const int order_time);
private:
void copy_from_post (comm_state& state,
const gdata* src, const ibbox& box);
void interpolate_from_post (comm_state& state,
const vector<const gdata*> srcs,
const vector<CCTK_REAL> times,
const ibbox& box,
const CCTK_REAL time,
const int order_space,
const int order_time);
void copy_from_wait (comm_state& state,
const gdata* src, const ibbox& box);
// Copy processor-local source data into communication send buffer
// of the corresponding destination processor
// The case when both source and destination are local is also handled here.
void copy_into_sendbuffer (comm_state& state,
const gdata* src, const ibbox& box);
// Copy processor-local destination data from communication recv buffer
// of the corresponding source processor
void copy_from_recvbuffer (comm_state& state,
const gdata* src, const ibbox& box);
// Interpolate processor-local source data into communication send buffer
// of the corresponding destination processor
// The case when both source and destination are local is also handled here.
void interpolate_into_sendbuffer (comm_state& state,
const vector<const gdata*> srcs,
const vector<CCTK_REAL> times,
const ibbox& box,
const CCTK_REAL time,
const int order_space,
const int order_time);
protected:
virtual void
copy_from_innerloop (const gdata* src, const ibbox& box) = 0;
virtual void
interpolate_from_innerloop (const vector<const gdata*>& srcs,
const vector<CCTK_REAL>& times,
const ibbox& box,
const CCTK_REAL time,
const int order_space,
const int order_time) = 0;
};
#endif // GDATA_HH
|
