void EmergencyExit(void) {
#ifndef __BIGSIM__
/* Delete _coreState to force any CkMessageWatcher to close down. */
if (CkpvAccess(_coreState) != NULL) {
delete CkpvAccess(_coreState);
CkpvAccess(_coreState) = NULL;
}
#endif
}
// this is called by the Charm++ runtime system
void _createTracecounter(char **argv)
{
DEBUGF(("%d/%d DEBUG: createTraceCounter\n", CmiMyPe(), CmiNumPes()));
CkpvInitialize(Trace*, _trace);
TraceCounter* tc = new TraceCounter(); _MEMCHECK(tc);
tc->traceInit(argv);
CkpvAccess(_trace) = tc;
CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
}
CollectionMgr::CollectionMgr(SlaveInitMsg *msg) : master(msg->master)
{
delete msg;
if (CkpvAccess(CollectionMgr_instance) == 0) {
CkpvAccess(CollectionMgr_instance) = this;
} else {
DebugM(1, "CollectionMgr::CollectionMgr() - another instance of CollectionMgr exists!\n");
}
}
void ConvComlibManager::doneCreating() {
ComlibPrintf("Called doneCreating\n");
if (busy) {
// we have to delay the table broadcast because we are in the middle of another one
doneCreatingScheduled = CmiTrue;
return;
}
// if we reach here it means we are not busy and we can proceed
busy = CmiTrue;
acksReceived = CmiNumPes() - 1;
int count = 0;
for (int i=1; i<=nstrats; ++i) {
if (strategyTable[i].isNew) {
count++;
}
}
if (count > 0) {
// create the wrapper and link the strategies there
StrategyWrapper sw(count);
count = 0;
for (int i=1; i<=nstrats; ++i) {
if (strategyTable[i].isNew) {
sw.position[count] = i;
sw.replace[count] = CmiFalse;
sw.strategy[count] = strategyTable[i].strategy;
count++;
CkpvAccess(conv_com_object).inSync(i);
}
}
// pup the wrapper into a message
PUP::sizer ps;
ps|sw;
char *msg = (char*)CmiAlloc(ps.size() + CmiReservedHeaderSize);
PUP::toMem pm(msg+CmiReservedHeaderSize);
//int size = ps.size();
//pm|size;
pm|sw;
//for (int i=CmiReservedHeaderSize; i<CmiReservedHeaderSize+size; ++i) {
// CmiPrintf("%x",((char*)msg)[i]);
//}
//CmiPrintf("\n");
CmiSetHandler(msg, CkpvAccess(comlib_receive_table));
CmiSyncBroadcastAndFree(ps.size()+CmiReservedHeaderSize, msg);
/* NOT USED NOW!
// call the finalizeCreation after the strategies has been packed
for (int i=0; i<strategyTable.size(); ++i) {
if (strategyTable[i].isNew) strategyTable[i].strategy->finalizeCreation();
}
*/
} else {
busy = CmiFalse;
}
}
static void namdInitPapiCounters(){
if(CkMyRank()==0){
//only initialize per OS process (i.e. a charm node)
int retval = PAPI_library_init(PAPI_VER_CURRENT);
if(retval != PAPI_VER_CURRENT) {
if(CkMyPe()==0){
CkPrintf("ERROR: PAPI library is not compatitible!");
CkExit();
}
}
#if CMK_SMP
//now only consider systems that are compatible with POSIX
if(PAPI_thread_init(pthread_self)!=PAPI_OK) {
if(CkMyPe()==0){
CkPrintf("ERROR: multi-thread mode in PAPI could not be initialized!");
CkExit();
}
}
#endif
}
CkpvInitialize(int *, papiEvents);
CkpvAccess(papiEvents) = new int[NUM_PAPI_EVENTS];
#if MEASURE_PAPI_CACHE
if(PAPI_query_event(PAPI_L1_DCM)==PAPI_OK) {
CkpvAccess(papiEvents)[0] = PAPI_L1_DCM;
}else{
if(CkMyPe()==0){
CkPrintf("WARNING: PAPI_L1_DCM doesn't exsit on this platform!\n");
}
//if not default to PAPI_TOT_INS
CkpvAccess(papiEvents)[0] = PAPI_TOT_INS;
}
if(PAPI_query_event(PAPI_L2_DCM)==PAPI_OK) {
CkpvAccess(papiEvents)[1] = PAPI_L2_DCM;
}else{
//if not default to PAPI_TOT_CYC
CkpvAccess(papiEvents)[1] = PAPI_TOT_CYC;
}
#elif MEASURE_PAPI_FLOPS
if(PAPI_query_event(PAPI_FP_INS)==PAPI_OK) {
CkpvAccess(papiEvents)[0] = PAPI_FP_INS;
}else{
if(CkMyPe()==0){
CkPrintf("WARNING: PAPI_FP_INS doesn't exsit on this platform!\n");
}
//if not default to PAPI_TOT_INS
CkpvAccess(papiEvents)[0] = PAPI_TOT_INS;
}
if(PAPI_query_event(PAPI_FMA_INS)==PAPI_OK) {
CkpvAccess(papiEvents)[1] = PAPI_FMA_INS;
}else{
//if not default to PAPI_TOT_CYC
CkpvAccess(papiEvents)[1] = PAPI_TOT_CYC;
}
#endif
}
/**
For each TraceFoo module, _createTraceFoo() must be defined.
This function is called in _createTraces() generated in moduleInit.C
*/
void _createTracememory(char **argv)
{
DEBUGF(("%d createTraceMemory\n", CkMyPe()));
CkpvInitialize(TraceMemory*, _trace);
CkpvAccess(_trace) = new TraceMemory(argv);
CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
/* Since we started after the beginning of the program, we missed a bunch of
* allocations. We cannot record what was allocated and then deleted, but we
* can still record all the memory that is still allocated.
*/
}
Communicate::Communicate(void)
{
CkpvInitialize(CmmTable, CsmMessages);
CsmHandlerIndex = CmiRegisterHandler((CmiHandler) CsmHandler);
CsmAckHandlerIndex = CmiRegisterHandler((CmiHandler) CsmAckHandler);
CkpvAccess(CsmMessages) = CmmNew();
if ( CmiMyNode() * 2 + 2 < CmiNumNodes() ) nchildren = 2;
else if ( CmiMyNode() * 2 + 1 < CmiNumNodes() ) nchildren = 1;
else nchildren = 0;
CkpvInitialize(int, CsmAcks);
CkpvAccess(CsmAcks) = nchildren;
}
/** Call add for every in-range array element on this processor */
void iterate(void)
{ /* Walk the groupTable for arrays (FIXME: get rid of _groupIDTable) */
int numGroups=CkpvAccess(_groupIDTable)->size();
for(int i=0;i<numGroups;i++) {
IrrGroup *obj = CkpvAccess(_groupTable)->find((*CkpvAccess(_groupIDTable))[i]).getObj();
if (obj->isArrMgr())
{ /* This is an array manager: examine its array elements */
mgr=(CkArray *)obj;
mgr->getLocMgr()->iterate(*this);
}
}
}
/// Method to acknowledge the ready status
void *comlibReadyHandler(void *msg) {
ComlibPrintf("[%d] Received ready acknowledgement\n",CmiMyPe());
CmiAssert(CkpvAccess(conv_com_object).acksReceived > 0);
if (--CkpvAccess(conv_com_object).acksReceived == 0) {
// ok, we are done. Do we have to broadcast a new table?
ComlibPrintf("Strategy table propagation finished\n");
CkpvAccess(conv_com_object).busy = CmiFalse;
if (CkpvAccess(conv_com_object).doneCreatingScheduled) {
CkpvAccess(conv_com_object).doneCreating();
}
}
CmiFree(msg);
return NULL;
}
void PipeBroadcastConverse::insertMessage(MessageHolder *cmsg){
ComlibPrintf("[%d] PipeBroadcastConverse::insertMessage %d\n",CkMyPe(),topology);
char *msg = cmsg->getMessage();
int size = cmsg->getSize();
if (size < pipeSize) {
// sending message in a single chunk
CmiSetHandler(msg, CkpvAccess(pipeline_handler));
CmiFragmentHeader *frag = getFragmentHeader(msg);
frag->senderPe = CkMyPe();
frag->msgSize = size;
propagate(msg, false);
} else {
// sending message in multiple chunk: message doesn't fit into the pipe:
// split it into chunks and propagate them individually
++seqNumber;
ComlibPrintf("[%d] Propagating message in multiple chunks (totalsize=%d)\n",CkMyPe(),size);
char *sendingMsg;
char *nextChunk = msg+CmiReservedHeaderSize;
int remaining = size-CmiReservedHeaderSize;
int reducedPipe = pipeSize-CmiReservedHeaderSize-sizeof(PipeBcastInfo);
int sendingMsgSize;
CmiSetHandler(msg, CkpvAccess(pipeline_frag_handler));
// send all the chunks one after the other
for (int i=0; i<(int)ceil(((double)size-CmiReservedHeaderSize)/reducedPipe); ++i) {
sendingMsgSize = reducedPipe<remaining? pipeSize : remaining+CmiReservedHeaderSize+sizeof(PipeBcastInfo);
sendingMsg = (char*)CmiAlloc(sendingMsgSize);
memcpy (sendingMsg, msg, CmiReservedHeaderSize);
PipeBcastInfo *info = (PipeBcastInfo*)(sendingMsg+CmiReservedHeaderSize);
info->srcPe = CkMyPe();
info->bcastPe = CkMyPe();
info->seqNumber = seqNumber;
info->chunkNumber = i;
info->chunkSize = reducedPipe<remaining ? reducedPipe : remaining;
info->messageSize = size;
memcpy (sendingMsg+CmiReservedHeaderSize+sizeof(PipeBcastInfo), nextChunk, info->chunkSize);
remaining -= info->chunkSize;
nextChunk += info->chunkSize;
propagate(sendingMsg, true);
}
}
//CmiSetHandler(msg, CsvAccess(pipeBcastPropagateHandle_frag));
//conversePipeBcast(msg, cmsg->getSize());
delete cmsg;
}
// move all atoms by a given vector
int ScriptTcl::Tcl_moveallby(ClientData clientData,
Tcl_Interp *interp, int argc, char *argv[]) {
ScriptTcl *script = (ScriptTcl *)clientData;
script->initcheck();
if (argc != 2) {
Tcl_SetResult(interp, "wrong # args", TCL_VOLATILE);
return TCL_ERROR;
}
char **fstring;
int fnum;
double x, y, z;
if (Tcl_SplitList(interp, argv[1], &fnum, &fstring) != TCL_OK)
return TCL_ERROR;
if ( (fnum != 3) ||
(Tcl_GetDouble(interp, fstring[0],&x) != TCL_OK) ||
(Tcl_GetDouble(interp, fstring[1],&y) != TCL_OK) ||
(Tcl_GetDouble(interp, fstring[2],&z) != TCL_OK) ) {
Tcl_SetResult(interp,"argument not a vector",TCL_VOLATILE);
Tcl_Free((char*)fstring);
return TCL_ERROR;
}
Tcl_Free((char*)fstring);
MoveAllByMsg *msg = new MoveAllByMsg;
msg->offset = Vector(x,y,z);
(CProxy_PatchMgr(CkpvAccess(BOCclass_group).patchMgr)).moveAllBy(msg);
script->barrier();
return TCL_OK;
}
void TraceBluegene::traceClose() {
DEBUGF(("%d TraceBluegene::traceClose\n", CkMyPe()));
bgUpdateProj(2);
if(pfp != 0) fclose(pfp);
pfp = NULL;
CkpvAccess(_traces)->removeTrace(this);
}
ComputeMgr::ComputeMgr()
{
CkpvAccess(BOCclass_group).computeMgr = thisgroup;
computeGlobalObject = 0;
computeGlobalResultsMsgSeq = -1;
computeGlobalResultsMsgMasterSeq = -1;
computeDPMEObject = 0;
computeEwaldObject = 0;
computeNonbondedCUDAObject = 0;
computeNonbondedMICObject = 0;
computeNonbondedWorkArrays = new ComputeNonbondedWorkArrays;
skipSplitting = 0;
#if defined(NAMD_MIC)
// Create the micPEData flag array (1 bit per PE) and initially set each PE as "not driving
// a MIC card" (unset). PEs that are driving MIC card will identify themselves during startup.
int numPEs = CkNumPes();
int numInts = ((numPEs + (sizeof(int)*8-1)) & (~(sizeof(int)*8-1))) / (sizeof(int)*8); // Round up to sizeof(int) then divide by the size of an int
micPEData = new int[numInts];
if (micPEData == NULL) { NAMD_die("Unable to allocate memory for micPEData"); }
memset(micPEData, 0, sizeof(int) * numInts);
#else
micPEData = NULL;
#endif
}
void
ComputeMgr::updateLocalComputes3()
{
ComputeMap *computeMap = ComputeMap::Object();
CProxy_ProxyMgr pm(CkpvAccess(BOCclass_group).proxyMgr);
ProxyMgr *proxyMgr = pm.ckLocalBranch();
ProxyMgr::nodecount = 0;
const int nc = computeMap->numComputes();
if ( ! CkMyRank() ) {
for (int i=0; i<nc; i++) {
computeMap->setNewNumPartitions(i,0);
if (computeMap->newNode(i) != -1) {
computeMap->setNode(i,computeMap->newNode(i));
computeMap->setNewNode(i,-1);
}
}
}
for(int i=0; i<computeFlag.size(); i++) createCompute(computeFlag[i], computeMap);
computeFlag.clear();
proxyMgr->removeUnusedProxies();
if (!CkMyPe())
{
CkStartQD(CkIndex_ComputeMgr::updateLocalComputes4((CkQdMsg*)0), &thishandle);
}
}
void ComputeMgr::sendCreateNonbondedMICSlave(int pe, int index) {
NonbondedMICSlaveMsg *msg = new NonbondedMICSlaveMsg;
msg->master = computeNonbondedMICObject;
msg->index = index;
CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
cm[pe].recvCreateNonbondedMICSlave(msg);
}
ComputeMsmSerialMgr::ComputeMsmSerialMgr() :
msmProxy(thisgroup), msmCompute(0), numSources(0), numArrived(0),
coordMsgs(0), coord(0), force(0), oldmsg(0), numAtoms(0),
msmsolver(0), msmcoord(0), msmforce(0)
{
CkpvAccess(BOCclass_group).computeMsmSerialMgr = thisgroup;
}
ComputeMsmSerial::ComputeMsmSerial(ComputeID c) :
ComputeHomePatches(c)
{
CProxy_ComputeMsmSerialMgr::ckLocalBranch(
CkpvAccess(BOCclass_group).computeMsmSerialMgr)->setCompute(this);
reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
}
void CpdBreakPointInit()
{
CkpvInitialize(void *, lastBreakPointMsg);
CkpvInitialize(void *, lastBreakPointObject);
CkpvInitialize(int, lastBreakPointIndex);
CpvInitialize(int, _debugMsg);
CpvInitialize(int, _debugChare);
CpvInitialize(CpdBpFuncTable_t *, breakPointEntryTable);
CkpvAccess(lastBreakPointMsg) = NULL;
CkpvAccess(lastBreakPointObject) = NULL;
CkpvAccess(lastBreakPointIndex) = 0;
CpvAccess(_debugMsg) = CkRegisterMsg("debug_msg",0,0,0,0);
CpvAccess(_debugChare) = CkRegisterChare("debug_Chare",0,TypeChare);
CkRegisterChareInCharm(CpvAccess(_debugChare));
CpvAccess(breakPointEntryTable) = new CpdBpFuncTable_t(10,0.5,CkHashFunction_int,CkHashCompare_int );
}
void ScriptTcl::setParameter(const char* param, int value) {
ScriptParamMsg *msg = new ScriptParamMsg;
strncpy(msg->param,param,MAX_SCRIPT_PARAM_SIZE);
sprintf(msg->value,"%d",value);
(CProxy_Node(CkpvAccess(BOCclass_group).node)).scriptParam(msg);
barrier();
}
static inline void _processBufferedMsgs(void)
{
CkNumberHandlerEx(_charmHandlerIdx,(CmiHandlerEx)_processHandler,
CkpvAccess(_coreState));
envelope *env;
while(NULL!=(env=(envelope*)CkpvAccess(_buffQ)->deq())) {
if(env->getMsgtype()==NewChareMsg || env->getMsgtype()==NewVChareMsg) {
if(env->isForAnyPE())
_CldEnqueue(CLD_ANYWHERE, env, _infoIdx);
else
_processHandler((void *)env, CkpvAccess(_coreState));
} else {
_processHandler((void *)env, CkpvAccess(_coreState));
}
}
}
// Function called right before an entry method
void CpdBeforeEp(int ep, void *obj, void *msg) {
#if CMK_CHARMDEBUG
if (CpvAccess(cmiArgDebugFlag)) {
DebugRecursiveEntry entry;
entry.previousChareID = setMemoryChareIDFromPtr(obj);
entry.alreadyUserCode = _entryTable[ep]->inCharm ? 0 : 1;
entry.memoryBackup = NULL;
entry.obj = obj;
if (msg != NULL) {
entry.msg = msg;
CmiReference(UsrToEnv(msg));
}
else entry.msg = NULL;
_debugData.push(entry);
setMemoryStatus(entry.alreadyUserCode);
//if (CkpvAccess(_debugEntryTable)[ep].isBreakpoint) printf("CpdBeforeEp breakpointed %d\n",ep);
memoryBackup = &_debugData.peek().memoryBackup;
if (!_entryTable[ep]->inCharm) {
CpdResetMemory();
CpdSystemExit();
}
CkVec<DebugPersistentCheck> &preExecutes = CkpvAccess(_debugEntryTable)[ep].preProcess;
for (int i=0; i<preExecutes.size(); ++i) {
preExecutes[i].object->cpdCheck(preExecutes[i].msg);
}
}
#endif
}
/**
* Create all groups in this processor (not called on processor zero).
* Notice that only groups created in mainchares are processed here;
* groups created later are processed as regular messages.
*/
static inline void _processBufferedBocInits(void)
{
CkCoreState *ck = CkpvAccess(_coreState);
CkNumberHandlerEx(_bocHandlerIdx,(CmiHandlerEx)_processHandler, ck);
register int i = 0;
PtrVec &inits=*CkpvAccess(_bocInitVec);
register int len = inits.size();
for(i=1; i<len; i++) {
envelope *env = inits[i];
if(env==0) CkAbort("_processBufferedBocInits: empty message");
if(env->isPacked())
CkUnpackMessage(&env);
_processBocInitMsg(ck,env);
}
delete &inits;
}
void _resume_charm_message()
{
CkNumberHandlerEx(_charmHandlerIdx,(CmiHandlerEx)_processHandler,
CkpvAccess(_coreState));
// CkNumberHandler(CpvAccess(CldHandlerIndex), (CmiHandler)CldHandler);
CkNumberHandler(index_skipCldHandler, (CmiHandler)_skipCldHandler);
}
/**
* This handler is used only during initialization. It receives messages from
* processor zero regarding Readonly Data (in one single message), Readonly Messages,
* Groups, and Nodegroups.
* The Readonly Data message also contains the total number of messages expected
* during the initialization phase.
* For Groups and Nodegroups, only messages with epoch=0 (meaning created from within
* a mainchare) are buffered for special creation, the other messages are buffered
* together with all the other regular messages by _bufferHandler (and will be flushed
* after all the initialization messages have been processed).
*/
static void _initHandler(void *msg, CkCoreState *ck)
{
CkAssert(CkMyPe()!=0);
register envelope *env = (envelope *) msg;
if (ck->watcher!=NULL) {
if (!ck->watcher->processMessage(&env,ck)) return;
}
switch (env->getMsgtype()) {
case BocInitMsg:
if (env->getGroupEpoch()==0) {
CkpvAccess(_numInitsRecd)++;
// _processBocInitMsg already handles QD
//CpvAccess(_qd)->process();
CkpvAccess(_bocInitVec)->insert(env->getGroupNum().idx, env);
} else _bufferHandler(msg);
break;
case NodeBocInitMsg:
if (env->getGroupEpoch()==0) {
CmiImmediateLock(CksvAccess(_nodeGroupTableImmLock));
CksvAccess(_numInitNodeMsgs)++;
CksvAccess(_nodeBocInitVec)->insert(env->getGroupNum().idx, env);
CmiImmediateUnlock(CksvAccess(_nodeGroupTableImmLock));
CpvAccess(_qd)->process();
} else _bufferHandler(msg);
break;
case ROMsgMsg:
CkpvAccess(_numInitsRecd)++;
CpvAccess(_qd)->process();
if(env->isPacked()) CkUnpackMessage(&env);
_processROMsgMsg(env);
break;
case RODataMsg:
CkpvAccess(_numInitsRecd)++;
CpvAccess(_qd)->process();
_numExpectInitMsgs = env->getCount();
_processRODataMsg(env);
break;
default:
CmiAbort("Internal Error: Unknown-msg-type. Contact Developers.\n");
}
DEBUGF(("[%d,%.6lf] _numExpectInitMsgs %d CkpvAccess(_numInitsRecd)+CksvAccess(_numInitNodeMsgs) %d+%d\n",CmiMyPe(),CmiWallTimer(),_numExpectInitMsgs,CkpvAccess(_numInitsRecd),CksvAccess(_numInitNodeMsgs)));
if(_numExpectInitMsgs&&(CkpvAccess(_numInitsRecd)+CksvAccess(_numInitNodeMsgs)==_numExpectInitMsgs)) {
_initDone();
}
}
static void CsmHandler(void *msg)
{
if ( CmiMyRank() ) NAMD_bug("Communicate CsmHandler on non-rank-zero pe");
// get start of user message
int *m = (int *) ((char *)msg+CmiMsgHeaderSizeBytes);
// sending node & tag act as tags
CmmPut(CkpvAccess(CsmMessages), 2, m, msg);
}
void ComputeMgr::sendBuildMICForceTable() {
CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
int pe = CkNodeFirst(CkMyNode());
int end = pe + CkNodeSize(CkMyNode());
for( ; pe != end; ++pe ) {
cm[pe].recvBuildMICForceTable();
}
}
void ComputeMgr::updateComputes2(CkQdMsg *msg)
{
delete msg;
CProxy_WorkDistrib wd(CkpvAccess(BOCclass_group).workDistrib);
WorkDistrib *workDistrib = wd.ckLocalBranch();
workDistrib->saveComputeMapChanges(CkIndex_ComputeMgr::updateComputes3(),thisgroup);
}
extern "C" void LBTurnInstrumentOff() {
#if CMK_LBDB_ON
if (CkpvAccess(lbdatabaseInited))
LBDatabase::Object()->CollectStatsOff();
else
_lb_args.statsOn() = 0;
#endif
}
void LBSetPeriod(double second) {
#if CMK_LBDB_ON
if (CkpvAccess(lbdatabaseInited))
LBDatabase::Object()->SetLBPeriod(second);
else
_lb_args.lbperiod() = second;
#endif
}
static inline void _sendStats(void)
{
DEBUGF(("[%d] _sendStats\n", CkMyPe()));
envelope *env = UsrToEnv(CkpvAccess(_myStats));
env->setSrcPe(CkMyPe());
CmiSetHandler(env, _exitHandlerIdx);
CmiSyncSendAndFree(0, env->getTotalsize(), (char *)env);
}
