自学教程：C++ CmiFree函数代码示例

void CqsEnumerateQueue(Queue q, void ***resp) {    void **result;    int num;    int i,j;    *resp = (void **)CmiAlloc(q->length * sizeof(void *));    j = 0;    result = CqsEnumeratePrioq(&(q->negprioq), &num);    for(i = 0; i < num; i++) {        (*resp)[j] = result[i];        j++;    }    CmiFree(result);    result = CqsEnumerateDeq(&(q->zeroprio), &num);    for(i = 0; i < num; i++) {        (*resp)[j] = result[i];        j++;    }    CmiFree(result);    result = CqsEnumeratePrioq(&(q->posprioq), &num);    for(i = 0; i < num; i++) {        (*resp)[j] = result[i];        j++;    }    CmiFree(result);}

/* called on PE 0 */static void cpuAffinityHandler(void *m){  static int count = 0;  static int nodecount = 0;  hostnameMsg *rec;  hostnameMsg *msg = (hostnameMsg *)m;  hostnameMsg *tmpm;  int tag, tag1, pe, myrank;  int npes = CmiNumPes();/*   for debug  char str[128];  skt_print_ip(str, msg->ip);  printf("hostname: %d %s/n", msg->pe, str);*/  CmiAssert(CmiMyPe()==0 && rankmsg != NULL);  tag = *(int*)&msg->ip;  pe = msg->pe;  if ((rec = (hostnameMsg *)CmmProbe(hostTable, 1, &tag, &tag1)) != NULL) {    CmiFree(msg);  }  else {    rec = msg;    rec->seq = nodecount;    nodecount++;                          /* a new node record */    CmmPut(hostTable, 1, &tag, msg);  }  myrank = rec->rank%rec->ncores;  while (in_exclude(myrank)) {             /* skip excluded core */    myrank = (myrank+1)%rec->ncores;    rec->rank ++;  }  rankmsg->ranks[pe] = myrank;             /* core rank */  rankmsg->nodes[pe] = rec->seq;           /* on which node */  rec->rank ++;  count ++;  if (count == CmiNumPes()) {    /* CmiPrintf("Cpuaffinity> %d unique compute nodes detected! /n", CmmEntries(hostTable)); */    tag = CmmWildCard;    while (tmpm = CmmGet(hostTable, 1, &tag, &tag1)) CmiFree(tmpm);    CmmFree(hostTable);#if 1    /* bubble sort ranks on each node according to the PE number */    {    int i,j;    for (i=0; i<npes-1; i++)      for(j=i+1; j<npes; j++) {        if (rankmsg->nodes[i] == rankmsg->nodes[j] &&               rankmsg->ranks[i] > rankmsg->ranks[j])         {          int tmp = rankmsg->ranks[i];          rankmsg->ranks[i] = rankmsg->ranks[j];          rankmsg->ranks[j] = tmp;        }      }    }#endif    CmiSyncBroadcastAllAndFree(sizeof(rankMsg)+CmiNumPes()*sizeof(int)*2, (void *)rankmsg);  }}

static void startMessage(Message *msg){#if 0    EmptyMsg m;       CmiFree(msg);    CmiSetHandler(&m, pva(iterHandler));    //fillMessage(mm);    pva(starttime) = CmiWallTimer();    CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);#else   Message *mm;   int size;   size = sizeof(Message)+sizes[pva(nextSize)].size;   mm = (Message *) CmiAlloc(size);   mm->srcpe = CmiMyPe();   mm->idx = pva(nextSize);   CmiSetHandler(mm, pva(iterHandler));   //fillMessage(mm);   pva(starttime) = CmiWallTimer();   CmiSyncSendAndFree(mm->srcpe, size, mm);   CmiFree(msg);#endif  }

int ScriptTcl::Tcl_replicaAtomSendrecv(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) {  ScriptTcl *script = (ScriptTcl *)clientData;  script->initcheck();  if ( ! Node::Object()->simParameters->replicaUniformPatchGrids ) {    Tcl_SetResult(interp,"replicaUniformPatchGrids is required for atom exchange",TCL_VOLATILE);    return TCL_ERROR;  }  if ( argc < 2 || argc > 3 ) {    Tcl_SetResult(interp,"bad arg count; args: dest ?source?",TCL_VOLATILE);    return TCL_ERROR;  }  int dest = -1;  if ( sscanf(argv[1], "%d", &dest) != 1 ) {    Tcl_SetResult(interp,"bad dest; args: dest ?source?",TCL_VOLATILE);    return TCL_ERROR;  }  int source = -1;  if ( argc == 3 ) {    if ( sscanf(argv[2], "%d", &source) != 1 ) {      Tcl_SetResult(interp,"bad source; args: dest ?source?",TCL_VOLATILE);      return TCL_ERROR;    }  }#if CMK_HAS_PARTITION  if (dest != CmiMyPartition()) {    DataMessage *recvMsg = NULL;    replica_sendRecv((char*)&(script->state->lattice), sizeof(Lattice), dest, CkMyPe(), &recvMsg, source, CkMyPe());    CmiAssert(recvMsg != NULL);    memcpy(&(script->state->lattice), recvMsg->data, recvMsg->size);    CmiFree(recvMsg);  }#endif  char str[40];  sprintf(str, "%d", dest);  script->setParameter("scriptArg1", str);  sprintf(str, "%d", source);  script->setParameter("scriptArg2", str);  CkpvAccess(_qd)->create(2 * PatchMap::Object()->numPatches());  script->runController(SCRIPT_ATOMSENDRECV);#if CMK_HAS_PARTITION  if (dest != CmiMyPartition()) {    DataMessage *recvMsg = NULL;    ControllerState *cstate = script->state->controller;    replica_sendRecv((char*)cstate, sizeof(ControllerState), dest, CkMyPe(), &recvMsg, source, CkMyPe());    CmiAssert(recvMsg != NULL);    memcpy(cstate, recvMsg->data, recvMsg->size);    CmiFree(recvMsg);  }#endif  return TCL_OK;}

void CqsDelete(Queue q){    CmiFree(q->negprioq.heap);    CmiFree(q->posprioq.heap);#if CMK_USE_STL_MSGQ    if (q->stlQ != NULL) delete (conv::msgQ<prio_t>*)(q->stlQ);#endif    CmiFree(q);}

static void CpdDebugCallAllocationTree(char *msg){  int numNodes;  int forPE;  void *tree;  if (CpdDebugGetAllocationTree == NULL) {    CmiPrintf("Error> Invoked CpdDebugCalloAllocationTree but no function initialized./nDid you forget to link in memory charmdebug?/n");    CcsSendReply(0, NULL);    return;  }  sscanf(msg+CmiMsgHeaderSizeBytes, "%d", &forPE);  if (CmiMyPe() == forPE) CpvAccess(allocationTreeDelayedReply) = CcsDelayReply();  if (forPE == -1 && CmiMyPe()==0) {    CpvAccess(allocationTreeDelayedReply) = CcsDelayReply();    CmiSetXHandler(msg, CpvAccess(CpdDebugCallAllocationTree_Index));    CmiSetHandler(msg, _debugHandlerIdx);    CmiSyncBroadcast(CmiMsgHeaderSizeBytes+strlen(msg+CmiMsgHeaderSizeBytes)+1, msg);  }  tree = CpdDebugGetAllocationTree(&numNodes);  if (forPE == CmiMyPe()) CpdDebugReturnAllocationTree(tree);  else if (forPE == -1) CmiReduceStruct(tree, CpdDebug_pupAllocationPoint, CpdDebug_MergeAllocationTree,                                CpdDebugReturnAllocationTree, CpdDebug_deleteAllocationPoint);  else CmiAbort("Received allocationTree request for another PE!");  CmiFree(msg);}

// For source not in rectangle case, forward to corner of rectangle//void RectMulticastStrategy::forwardMulticast(envelope *env,                                               ComlibRectSectionHashObject *obj) {    ComlibPrintf("[%d] forwardMulticast /n", CkMyPe());           int *pelist = obj->pelist;    int npes    = obj->npes;    if(npes == 0) {        CmiFree(env);        return;        }    // handler is changed to special root handler    CmiSetHandler(env, handlerId);    ((CmiMsgHeaderExt *) env)->stratid = getInstance();    //Collect Multicast Statistics    RECORD_SENDM_STATS(getInstance(), env->getTotalsize(), pelist, npes);        CkPackMessage(&env);    //Sending a remote multicast    ComlibMulticastMsg *cbmsg = (ComlibMulticastMsg *)EnvToUsr(env);    int sectionID=cbmsg->_cookie.sInfo.cInfo.id;    //   CmiSyncListSendAndFree(npes, pelist, env->getTotalsize(), (char*)env);    CmiSyncSendAndFree(obj->cornerRoot, env->getTotalsize(), (char*)env);    //CmiSyncBroadcastAndFree(env->getTotalsize(), (char*)env);}

static void CpdList_ccs_list_items_fmt(char *msg){  CpdListItemsRequest req;  CpdListAccessor *acc=CpdListHeader_ccs_list_items(msg,req);  if (acc!=NULL) {    int bufLen;    {       PUP_toNetwork_sizer ps;      PUP_fmt p(ps);       pupCpd(p,acc,req);      bufLen=ps.size();     }    char *buf=new char[bufLen];    {       PUP_toNetwork_pack pp(buf);       PUP_fmt p(pp);      pupCpd(p,acc,req);      if (pp.size()!=bufLen)	CmiError("ERROR! Sizing/packing length mismatch for %s list pup function (%d sizing, %d packing)/n",		acc->getPath(),bufLen,pp.size());    }    CcsSendReply(bufLen,(void *)buf);    delete[] buf;  }  CmiFree(msg);}

static void setupMessage(Message *msg){    Message *mm;    int     i, size;    int nextSize =  msg->idx;     size = sizeof(Message)+sizes[nextSize].size;     buffer_msgs = (char*)malloc((sizes[nextSize].numiter) * sizeof(Message*));    for(i=0; i<sizes[nextSize].numiter; i++)    {        mm = (Message*)CmiAlloc(size);        mm->srcpe = CmiMyPe();        CmiSetHandler(mm, pva(iterHandler));        //mm->idx = pva(nextSize);        //*((Message**)buffer_msgs+i*sizeof(char*)) = mm;        ((Message**)buffer_msgs)[i] = mm;    }    mm = (Message *) CmiAlloc(size);    mm->srcpe = CmiMyPe();    mm->idx = nextSize;    CmiSetHandler(mm, pva(startHandler));    //fillMessage(mm);//CmiAssert(msg->srcpe == 0);    CmiSyncSendAndFree(msg->srcpe, size, mm);    CmiFree(msg);}

/** Double the size of a Priority Queue's hash table */void CqsPrioqRehash(_prioq pq){    int oldHsize = pq->hash_key_size;    int newHsize = oldHsize * 2;    unsigned int hashval;    _prioqelt pe, pe1, pe2;    int i,j;    _prioqelt *ohashtab = pq->hashtab;    _prioqelt *nhashtab = (_prioqelt *)CmiAlloc(newHsize*sizeof(_prioqelt));    pq->hash_key_size = newHsize;    for(i=0; i<newHsize; i++)        nhashtab[i] = 0;    for(i=0; i<oldHsize; i++) {        for(pe=ohashtab[i]; pe; ) {            pe2 = pe->ht_next;            hashval = pe->pri.bits;            for (j=0; j<pe->pri.ints; j++) hashval ^= pe->pri.data[j];            hashval = (hashval&0x7FFFFFFF)%newHsize;            pe1=nhashtab[hashval];            pe->ht_next = pe1;            pe->ht_handle = (nhashtab+hashval);            if (pe1) pe1->ht_handle = &(pe->ht_next);            nhashtab[hashval]=pe;            pe = pe2;        }    }    pq->hashtab = nhashtab;    pq->hash_key_size = newHsize;    CmiFree(ohashtab);}

static void startNextSize(EmptyMsg *msg){  EmptyMsg m;  Message *mm;  int i; //CmiAssert(CmiMyPe()==0);  pva(nextSize)++;  if(pva(nextSize) == pva(numSizes)) {    pva(nextSize) = -1;    CmiSetHandler(&m, pva(nbrHandler));    CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);  } else {    int size = sizeof(Message)+sizes[pva(nextSize)].size;        buffer_msgs = (char*)malloc((sizes[pva(nextSize)].numiter) * sizeof(Message*));    for(i=0; i<sizes[pva(nextSize)].numiter; i++)    {        mm = CmiAlloc(size);        mm->srcpe = CmiMyPe();        mm->idx = pva(nextSize);        CmiSetHandler(mm, pva(bounceHandler));        //*((Message**)(buffer_msgs+i*sizeof(char*))) = mm;        ((Message**)buffer_msgs)[i] = mm;    }    mm = (Message *) CmiAlloc(size);    mm->srcpe = CmiMyPe();    mm->idx = pva(nextSize);    CmiSetHandler(mm, pva(setupHandler));    //fillMessage(mm);    CmiSyncSendAndFree(pva(nextNbr), size, mm);  }  CmiFree(msg);}

static void startNextNbr(EmptyMsg *msg){  EmptyMsg m;  TimeMessage *tm;  int i, size;//CmiAssert(CmiMyPe()==0);  CmiFree(msg);  pva(nextNbr)++;  if(pva(nextNbr) == CmiMyNode()) {    CmiSetHandler(&m, pva(nbrHandler));    CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);    return;  }  if(pva(nextNbr) == CmiNumNodes()) {    pva(nextNbr) = -1;    CmiSetHandler(&m, pva(nodeHandler));    CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);    size = sizeof(TimeMessage)+pva(numSizes)*CmiNumNodes()*sizeof(double);    tm = (TimeMessage *) CmiAlloc(size);    for(i=0;i<CmiNumNodes();i++)      memcpy(tm->data+i*pva(numSizes),pva(times)[i],             sizeof(double)*pva(numSizes));    tm->srcNode = CmiMyNode();    CmiSetHandler(tm, pva(timeHandler));    CmiSyncSendAndFree(0, size, tm);  } else {    CmiSetHandler(&m, pva(sizeHandler));    CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);  }}

extern "C" void req_fw_handler(char *msg){  int offset = CmiReservedHeaderSize + sizeof(CcsImplHeader);  CcsImplHeader *hdr = (CcsImplHeader *)(msg+CmiReservedHeaderSize);  int destPE = (int)ChMessageInt(hdr->pe);  if (CmiMyPe() == 0 && destPE == -1) {    /* Broadcast message to all other processors */    int len=CmiReservedHeaderSize+sizeof(CcsImplHeader)+ChMessageInt(hdr->len);    CmiSyncBroadcast(len, msg);  }  else if (destPE < -1) {    /* Multicast the message to your children */    int len=CmiReservedHeaderSize+sizeof(CcsImplHeader)+ChMessageInt(hdr->len)-destPE*sizeof(ChMessageInt_t);    int index, child, i;    int *pes = (int*)(msg+CmiReservedHeaderSize+sizeof(CcsImplHeader));    ChMessageInt_t *pes_nbo = (ChMessageInt_t *)pes;    offset -= destPE * sizeof(ChMessageInt_t);    if (ChMessageInt(pes_nbo[0]) == CmiMyPe()) {      for (index=0; index<-destPE; ++index) pes[index] = ChMessageInt(pes_nbo[index]);    }    for (index=0; index<-destPE; ++index) {      if (pes[index] == CmiMyPe()) break;    }    child = (index << 2) + 1;    for (i=0; i<4; ++i) {      if (child+i < -destPE) {        CmiSyncSend(pes[child+i], len, msg);      }    }  }  CcsHandleRequest(hdr, msg+offset);  CmiFree(msg);}

static void reduction_handler(void *msg) {  int i=0;  int idx = CpvAccess(nextidx);  EmptyMsg emsg;  sizes[idx].time = CmiWallTimer() - CpvAccess(starttime);  CmiFree(msg);  CpvAccess(numiter) = 0;  idx++;  if(sizes[idx].size == (-1)) {    print_results("Consecutive CmiSyncBroadcastAllAndFree");    CpvAccess(nextidx) = 0;    CpvAccess(numiter) = 0;    while(sizes[i].size != (-1)) {      sizes[i].time = 0;      i++;    }    CmiSetHandler(&emsg, CpvAccess(sync_reply));    CpvAccess(lasttime) = CmiWallTimer();     CmiSyncSend(CpvAccess(currentPe), sizeof(EmptyMsg), &emsg);    return;  } else {    CpvAccess(nextidx) = idx;    msg = CmiAlloc(CmiMsgHeaderSizeBytes+sizes[idx].size);    CmiSetHandler(msg, CpvAccess(bcast_handler));    CpvAccess(starttime) = CmiWallTimer();    CmiSyncBroadcastAllAndFree(CmiMsgHeaderSizeBytes+sizes[idx].size, msg);  }}

PeTable :: ~PeTable() {  int i;  for (i=0;i<NumPes;i++) CmiFree(PeList[i]);  CmiFree(PeList);  delete msgnum;  delete MaxSize;  GarbageCollect();  //CmiFree(ptrlist);  PTinfo *tmp;  while (PTFreeChunks) {    tmp=PTFreeChunks;    PTFreeChunks=PTNEXTCHUNK(tmp);    CmiFree(tmp);  }  // delete FreeList;}

static void sync_reply(void *msg) {  ptimemsg tmsg = (ptimemsg)CmiAlloc(sizeof(timemsg));  tmsg->time = CmiWallTimer();  CmiSetHandler(tmsg, CpvAccess(sync_starter));  CmiSyncSendAndFree(0, sizeof(timemsg), tmsg);  CmiFree(msg);}

void _libExitHandler(envelope *env){	switch(env->getMsgtype()) {		case StartExitMsg:			CkAssert(CkMyPe()==0);			// else goto next		case ExitMsg:			CkAssert(CkMyPe()==0);			if(_libExitStarted) {				CmiFree(env);				return;			}			_libExitStarted = 1;			env->setMsgtype(ReqStatMsg);			env->setSrcPe(CkMyPe());			// if exit in ring, instead of broadcasting, send in ring			if (_ringexit){				const int stride = CkNumPes()/_ringtoken;				int pe = 0; while (pe<CkNumPes()) {					CmiSyncSend(pe, env->getTotalsize(), (char *)env);					pe += stride;				}				CmiFree(env);			}else{				CmiSyncBroadcastAllAndFree(env->getTotalsize(), (char *)env);			}				break;		case ReqStatMsg:			if (_ringexit) {				int stride = CkNumPes()/_ringtoken;				int pe = CkMyPe()+1;				if (pe < CkNumPes() && pe % stride != 0)					CmiSyncSendAndFree(pe, env->getTotalsize(), (char *)env);				else					CmiFree(env);			}			else				CmiFree(env);			//everyone exits here - there may be issues with leftover messages in the queue			_libExitStarted = 0;			CpvAccess(charmLibExitFlag) = 1;			break;		default:			CmiAbort("Internal Error(_libExitHandler): Unknown-msg-type. Contact Developers./n");	}}

extern "C" void immediatering_finishHandler(void *msg) {  CmiFree(msg);  waitFor ++;  // only send one megatest_finish when all tests finish  if (waitFor%numTests == 0) {    megatest_finish(); // Not safe from inside immediate  }}

/** * Converse handler receiving a signal from another processors in the same node. * (On _sendTrigger there is the explanation of why this is necessary) * Simply check if with the NodeGroup processed by another processor we reached * the expected count. Notice that it can only be called before _initDone: after * _initDone, a message destined for this handler will go instead to the _discardHandler. */static void _triggerHandler(envelope *env){  if (_numExpectInitMsgs && CkpvAccess(_numInitsRecd) + CksvAccess(_numInitNodeMsgs) == _numExpectInitMsgs)  {    DEBUGF(("Calling Init Done from _triggerHandler/n"));    _initDone();  }  if (env!=NULL) CmiFree(env);}

static void bcast_reply(void *msg){  ptimemsg tmsg = (ptimemsg)CmiAlloc(sizeof(timemsg));  tmsg->time = CmiWallTimer();  tmsg->srcpe = CmiMyPe();  CmiSetHandler(tmsg, CpvAccess(bcast_central));  CmiSyncSendAndFree(0, sizeof(timemsg), tmsg);  CmiFree(msg);}

static void CpdDebugHandlerStatus(char *msg) {#if ! CMK_NO_SOCKETS      ChMessageInt_t reply[2];  reply[0] = ChMessageInt_new(CmiMyPe());  reply[1] = ChMessageInt_new(CpdIsFrozen() ? 0 : 1);  CcsSendReply(2*sizeof(ChMessageInt_t), reply);#endif  CmiFree(msg);}

static void startNextNode(EmptyMsg *msg){  EmptyMsg m;  CmiFree(msg);  if((CmiMyNode()+1) != CmiNumNodes()) {    CmiSetHandler(&m, pva(nbrHandler));    CmiSyncSend(pva(nodeList)[CmiMyNode()+1], sizeof(EmptyMsg), &m);  }}

//Get the length of the given list:static void CpdList_ccs_list_len(char *msg){  const ChMessageInt_t *req=(const ChMessageInt_t *)(msg+CmiReservedHeaderSize);  CpdListAccessor *acc=CpdListLookup(req);  if (acc!=NULL) {    ChMessageInt_t reply=ChMessageInt_new(acc->getLength());    CcsSendReply(sizeof(reply),(void *)&reply);  }  CmiFree(msg);}

static void bounceMessage(Message *msg){    Message *mm;    int iter = msg->iter;      mm = *((Message**)(buffer_msgs + iter*sizeof(char*)));     CmiSetHandler(mm, pva(iterHandler));//CmiAssert(msg->srcpe==0);    CmiSyncSendAndFree(msg->srcpe, sizeof(Message)+sizes[msg->idx].size, mm);    CmiFree(msg);}

/*Receives reply messages passed up fromconverse to node 0.*/static void rep_fw_handler(char *msg){  int len;  char *r=msg+CmiReservedHeaderSize;  CcsImplHeader *hdr=(CcsImplHeader *)r;   r+=sizeof(CcsImplHeader);  len=ChMessageInt(hdr->len);  CcsImpl_reply(hdr,len,r);  CmiFree(msg);}

static inline void _processRODataMsg(envelope *env){  //Unpack each readonly:  if(!CmiMyRank()) {    PUP::fromMem pu((char *)EnvToUsr(env));    for(size_t i=0;i<_readonlyTable.size();i++) {      _readonlyTable[i]->pupData(pu);    }  }  CmiFree(env);}

static void _discardHandler(envelope *env){//  MESSAGE_PHASE_CHECK(env);  DEBUGF(("[%d] _discardHandler called./n", CkMyPe()));#if CMK_MEM_CHECKPOINT  //CkPrintf("[%d] _discardHandler called!/n", CkMyPe());  if (CkInRestarting()) CpvAccess(_qd)->process();#endif  CmiFree(env);}

CmiHandler ackHandlerFunc(char *msg){    CmiFree(msg);    CpvAccess(ackCount)++;    int max = CpvAccess(twoway) ? CmiNumPes() : CmiNumPes()/2;    if(CpvAccess(ackCount) == max) {      void *sendmsg = CmiAlloc(CmiMsgHeaderSizeBytes);      CmiSetHandler(sendmsg,CpvAccess(exitHandler));      CmiSyncBroadcastAllAndFree(CmiMsgHeaderSizeBytes,sendmsg);    }    return 0;}

void GarbageCollectMsg(OutgoingMsg ogm){  MACHSTATE2(3,"GarbageCollectMsg called on ogm %p refcount %d",ogm,ogm->refcount);	if (ogm->refcount == 0) {    if (ogm->freemode == 'A') {      ogm->freemode = 'X';    } else {      if (ogm->freemode != 'G') CmiFree(ogm->data);      FreeOutgoingMsg(ogm);    }  }}