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
|
#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 {
protected: // should be readonly
// Fields
void * _storage; // A copy of the storage pointer
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;
// 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);
void
transfer_from (comm_state & state,
vector<gdata const *> const & srcs,
vector<CCTK_REAL> const & times,
ibbox const & dstbox,
ibbox const & srcbox,
CCTK_REAL time,
int order_space,
int order_time);
protected:
void
find_source_timelevel (vector <CCTK_REAL> const & times,
CCTK_REAL time,
int order_time,
int & timelevel0,
int & ntimelevels)
const;
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;
};
#endif // GDATA_HH
|
