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
210
211
212
213
214
215
216
217
218
219
|
// $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetLib/src/gdata.hh,v 1.24 2004/04/19 07:56:35 schnetter Exp $
#ifndef GDATA_HH
#define GDATA_HH
#include <assert.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <vector>
#include "cctk.h"
#include "defs.hh"
#include "dist.hh"
#include "bbox.hh"
#include "operators.hh"
#include "vect.hh"
using namespace std;
template<int D>
class gdata;
// State information for communications
enum astate { state_recv, state_send, state_wait, state_done };
template<int D>
struct comm_state {
astate thestate;
comm_state ();
void step ();
bool done ();
~comm_state ();
vector<gdata<D>*> tmps;
size_t current;
};
// A generic data storage without type information
template<int D>
class gdata {
// Types
typedef vect<int,D> ivect;
typedef bbox<int,D> ibbox;
protected: // should be readonly
// Fields
int varindex; // Cactus variable index, or -1
operator_type transport_operator;
double wtime_isend, wtime_isendwait;
double wtime_irecv, wtime_irecvwait;
bool _has_storage; // has storage associated (on some processor)
bool _owns_storage; // owns the storage
// (only valid if there is storage on this processor; it means that
// the memory is allocated and freed by this class)
int _size; // size
int _proc; // stored on processor
ivect _shape, _stride; // shape and index order
ibbox _extent; // bbox for all data
bool comm_active;
MPI_Request request;
int tag; // MPI tag for this object
public:
// Constructors
gdata (const int varindex,
const operator_type transport_operator = op_error);
// Destructors
virtual ~gdata ();
// Pseudo constructors
virtual gdata<D>*
make_typed (const int varindex,
const operator_type transport_operator = op_error) const = 0;
// Processor management
virtual void change_processor (comm_state<D>& state,
const int newproc, void* const mem=0) = 0;
protected:
virtual void change_processor_recv (const int newproc, void* const mem=0) = 0;
virtual void change_processor_send (const int newproc, void* const mem=0) = 0;
virtual void change_processor_wait (const int newproc, void* const mem=0) = 0;
public:
// Storage management
virtual void transfer_from (gdata<D>* src) = 0;
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;
}
bool owns_storage () const {
assert (_has_storage);
return _owns_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());
}
// Data manipulators
public:
void copy_from (comm_state<D>& state,
const gdata* src, const ibbox& box);
private:
void copy_from_nocomm (const gdata* src, const ibbox& box);
void copy_from_recv (comm_state<D>& state,
const gdata* src, const ibbox& box);
void copy_from_send (comm_state<D>& state,
const gdata* src, const ibbox& box);
void copy_from_wait (comm_state<D>& state,
const gdata* src, const ibbox& box);
public:
void interpolate_from (comm_state<D>& 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 interpolate_from_nocomm (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 interpolate_from_recv (comm_state<D>& 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 interpolate_from_send (comm_state<D>& 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 interpolate_from_wait (comm_state<D>& 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);
public:
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
|
