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
|
#ifndef GDATA_HH
#define GDATA_HH
#include <cassert>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <string>
#include <vector>
#include "cctk.h"
#include "bbox.hh"
#include "commstate.hh"
#include "defs.hh"
#include "dist.hh"
#include "operators.hh"
#include "timestat.hh"
#include "vect.hh"
using namespace std;
// A generic data storage without type information
class gdata {
static list<gdata*> allgdata;
list<gdata*>::iterator allgdatai;
protected: // should be readonly
// Fields
void * _storage; // A copy of the storage pointer
public:
const int varindex; // Cactus variable index, or -1
protected:
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
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);
// 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 = 0;
// Storage management
virtual void allocate (const ibbox& extent, const int proc,
void* const memptr = NULL, size_t const memsize = 0) = 0;
virtual void free () = 0;
virtual size_t allocsize (const ibbox& extent, const int proc) const = 0;
// Accessors
bool has_storage () const {
return _has_storage;
}
void const *
storage ()
const
{
assert (_has_storage);
return _storage;
}
void *
storage ()
{
assert (_has_storage);
return _storage;
}
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;
}
int elementsize () const {
return c_datatype_size();
}
// 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;
virtual size_t c_datatype_size () const = 0;
// Data manipulators
public:
void
copy_from (comm_state & state,
gdata const * src,
ibbox const & box,
int dstproc,
int srcproc);
void
transfer_from (comm_state & state,
vector<gdata const *> const & srcs,
vector<CCTK_REAL> const & times,
ibbox const & dstbox,
ibbox const & srcbox,
int dstproc,
int srcproc,
CCTK_REAL time,
int order_space,
int order_time);
protected:
static
void
find_source_timelevel (vector <CCTK_REAL> const & times,
CCTK_REAL time,
int order_time,
operator_type transport_operator,
int & timelevel0,
int & ntimelevels);
private:
virtual
void
copy_from_innerloop (gdata const * gsrc,
ibbox const & box)
= 0;
virtual
void
transfer_from_innerloop (vector <gdata const *> const & gsrcs,
vector <CCTK_REAL> const & times,
ibbox const & box,
CCTK_REAL time,
int order_space,
int order_time)
= 0;
public:
virtual size_t memory () const CCTK_ATTRIBUTE_PURE = 0;
static size_t allmemory () CCTK_ATTRIBUTE_PURE;
virtual ostream& output (ostream& os) const = 0;
};
inline size_t memoryof (gdata const & d) CCTK_ATTRIBUTE_PURE;
inline size_t memoryof (gdata const & d)
{
return d.memory ();
}
inline ostream& operator<< (ostream& os, const gdata& d)
{
return d.output(os);
}
#endif // GDATA_HH
|
