17 #define MIN_DEBUG_LEVEL 4
44 delete [] computePtrs;
50 int computeCount = nComputes;
51 for (
int i=0; i<nComputes; i++) {
54 if (! (computePtrs[i]->cid == i)) {
55 DebugM(4,
"ComputeID("<<computePtrs[i]->cid<<
") != ComputeID("
60 DebugM(4,
"Compute Count = " << computeCount <<
"\n");
65 DebugM(4,
"Packing ComputeMap\n");
67 msg->
put(nComputes,computeData.begin());
72 DebugM(4,
"Unpacking ComputeMap\n");
75 if ( old && old != nComputes ) {
76 NAMD_bug(
"number of computes in new ComputeMap has changed!\n");
78 computeData.resize(nComputes);
79 msg->
get(nComputes,computeData.begin());
83 if ( ! computePtrs ) {
84 computePtrs =
new Compute*[nComputes];
85 memset(computePtrs, 0, nComputes*
sizeof(
Compute*));
90 if ( ! computePtrs )
NAMD_bug(
"ComputeMap::extendPtrs() 1");
92 nComputes = computeData.size();
93 if ( nComputes > oldN ) {
94 Compute **oldPtrs = computePtrs;
95 computePtrs =
new Compute*[nComputes];
96 memcpy(computePtrs, oldPtrs, oldN*
sizeof(
Compute*));
97 memset(computePtrs+oldN, 0, (nComputes-oldN)*
sizeof(
Compute*));
105 return computeData[cid].numPids;
111 return computeData[cid].pids[i].pid;
116 return computeData[cid].pids[i].trans;
123 return computeData[cid].type;
131 return computeData[cid].partition;
138 return computeData[cid].numPartitions;
146 computeData.resize(500);
147 computeData.resize(0);
158 NAMD_bug(
"ComputeMap::storeCompute called with maxPids > numPidsAllocated");
165 computeData.resize(nComputes);
167 computeData[cid].node=inode;
169 computeData[cid].type =
type;
173 computeData[cid].numPids = 0;
175 #if defined(NAMD_MIC)
178 computeData[cid].directToDevice = 0;
187 const int cid = computeData.size();
188 computeData.resize(cid+1);
190 computeData[cid] = computeData[src];
192 computeData[cid].node = -1;
200 computeData[cid].pids[computeData[cid].numPids].pid=
pid;
201 computeData[cid].pids[computeData[cid].numPids].trans=
trans;
202 computeData[cid].numPids++;
208 DebugM(2,
"---------------------------------------");
209 DebugM(2,
"---------------------------------------\n");
211 DebugM(2,
"nComputes = " << nComputes <<
'\n');
212 DebugM(2,
"nAllocated = " << nComputes <<
'\n');
213 for(
int i=0; i < nComputes; i++)
215 DebugM(2,
"Compute " << i <<
'\n');
216 DebugM(2,
" node = " << computeData[i].
node <<
'\n');
218 for(
int j=0; j < computeData[i].numPids; j++)
224 DebugM(2,
"\n---------------------------------------");
225 DebugM(2,
"---------------------------------------\n");
229 #ifdef MEM_OPT_VERSION
230 const char *fname =
"computeMap.opt";
232 const char *fname =
"computeMap.orig";
235 FILE *ofp = fopen(fname,
"w");
236 fprintf(ofp,
"---------------------------------------");
237 fprintf(ofp,
"---------------------------------------\n");
239 fprintf(ofp,
"nComputes = %d\n", nComputes);
240 fprintf(ofp,
"nAllocated = %d\n", nComputes);
241 for(
int i=0; i < nComputes; i++)
243 fprintf(ofp,
"Compute %d\n", i);
244 fprintf(ofp,
" node = %d\n",computeData[i].
node);
245 fprintf(ofp,
" numPids = %d\n",computeData[i].
numPids);
246 fprintf(ofp,
" type = %d\n",computeData[i].
type);
247 for(
int j=0; j < computeData[i].numPids; j++)
249 fprintf(ofp,
"%d ",computeData[i].pids[j].
pid);
253 fprintf(ofp,
"\n---------------------------------------");
254 fprintf(ofp,
"---------------------------------------\n");
264 static int count = 0;
266 sprintf(f,
"%s.%d", fname, count++);
267 FILE *fp = fopen(f,
"w");
268 CmiAssert(fp != NULL);
269 fprintf(fp,
"%d\n", nComputes);
270 for(
int i=0; i < nComputes; i++)
272 fprintf(fp,
"%d\n", computeData[i].
node);
275 CkPrintf(
"ComputeMap has been stored in %s.\n", f);
280 FILE *fp = fopen(fname,
"r");
281 CmiAssert(fp != NULL);
283 fscanf(fp,
"%d\n", &n);
284 CmiAssert(n == nComputes);
285 for(
int i=0; i < nComputes; i++)
287 fscanf(fp,
"%d\n", &computeData[i].
node);
293 #if defined(NAMD_MIC)
295 void ComputeMap::setDirectToDevice(
const ComputeID cid,
const int d) {
296 if (cid < 0 || cid >= nComputes) {
297 NAMD_bug(
"ComputeMap::setDirectToDevice() called with an invalid cid value");
299 computeData[cid].directToDevice = ((d == 0) ? (0) : (1));
302 int ComputeMap::directToDevice(
const ComputeID cid)
const {
303 if (cid < 0 || cid >= nComputes) {
304 NAMD_bug(
"ComputeMap::directToDevice() called with an invalid cid value");
306 return computeData[cid].directToDevice;
309 #endif // defined(NAMD_MIC)
void saveComputeMap(const char *fname)
static void partition(int *order, const FullAtom *atoms, int begin, int end)
void loadComputeMap(const char *fname)
MIStream * get(char &data)
ComputeID storeCompute(int node, int maxPids, ComputeType type, int partition=-1, int numPartitions=0)
void printComputeMap(void)
void NAMD_bug(const char *err_msg)
ComputeType type(ComputeID cid)
int numPartitions(ComputeID cid)
int partition(ComputeID cid)
static ComputeMap * Instance()
void newPid(ComputeID cid, int pid, int trans=13)
ComputeID cloneCompute(ComputeID src, int partition)
int numPids(ComputeID cid)
MOStream * put(char data)
int pid(ComputeID cid, int i)
int trans(ComputeID cid, int i)
void unpack(MIStream *msg)