Added checking for null pointer returned by every malloc and new.
authorMilind Bhandarkar <milind@cs.uiuc.edu>
Sun, 1 Aug 1999 13:07:33 +0000 (13:07 +0000)
committerMilind Bhandarkar <milind@cs.uiuc.edu>
Sun, 1 Aug 1999 13:07:33 +0000 (13:07 +0000)
23 files changed:
src/arch/net/machine.c
src/ck-core/charm++.h
src/ck-core/ck.C
src/ck-core/ck.h
src/ck-core/ckarray.C
src/ck-core/ckfutures.C
src/ck-core/debug-message.C
src/ck-core/debug-object.C
src/ck-core/info.C
src/ck-core/init.C
src/ck-core/init.h
src/ck-core/qd.C
src/ck-core/qd.h
src/ck-core/register.C
src/ck-core/tempo.C
src/conv-core/conv-conds.c
src/conv-core/convcore.c
src/conv-core/converse.h
src/conv-core/cpath.c
src/conv-core/cpthreads.c
src/conv-core/fifo.c
src/conv-core/futures.c
src/conv-core/threads.c

index c301ee92775fa57f956a3133fb9e6d6eeb5ae911..444a78ce1c8c87497177169e4674c03286ca7a17 100644 (file)
@@ -331,6 +331,7 @@ static char *strdupl(s) char *s;
 {
   int len = strlen(s);
   char *res = (char *)malloc(len+1);
+  _MEMCHECK(res);
   strcpy(res, s);
   return res;
 }
@@ -658,6 +659,7 @@ PCQueue PCQueueCreate()
   circ = (CircQueue)calloc(1, sizeof(struct CircQueueStruct));
 
   Q = (PCQueue)malloc(sizeof(struct PCQueueStruct));
+  _MEMCHECK(Q);
   Q->head = circ;
   Q->tail = circ;
   return Q;
@@ -951,8 +953,9 @@ static OutgoingMsg   Cmi_freelist_outgoing;
 
 #define MallocImplicitDgram(dg) {\
   ImplicitDgram d = Cmi_freelist_implicit;\
-  if (d==0) d = ((ImplicitDgram)malloc(sizeof(struct ImplicitDgramStruct)));\
-  else Cmi_freelist_implicit = d->next;\
+  if (d==0) {d = ((ImplicitDgram)malloc(sizeof(struct ImplicitDgramStruct)));\
+             _MEMCHECK(d);\
+  } else Cmi_freelist_implicit = d->next;\
   dg = d;\
 }
 
@@ -964,9 +967,10 @@ static OutgoingMsg   Cmi_freelist_outgoing;
 
 #define MallocExplicitDgram(dg) {\
   ExplicitDgram d = Cmi_freelist_explicit;\
-  if (d==0) d = ((ExplicitDgram)malloc \
+  if (d==0) d = ((ExplicitDgram)malloc \
                   (sizeof(struct ExplicitDgramStruct) + Cmi_max_dgram_size));\
-  else Cmi_freelist_explicit = d->next;\
+              _MEMCHECK(d);\
+  } else Cmi_freelist_explicit = d->next;\
   dg = d;\
 }
 
@@ -974,7 +978,7 @@ static OutgoingMsg   Cmi_freelist_outgoing;
 
 #define FreeOutgoingMsg(m) (free(m))
 #define MallocOutgoingMsg(m)\
-   (m=(OutgoingMsg)malloc(sizeof(struct OutgoingMsgStruct)))
+    {(m=(OutgoingMsg)malloc(sizeof(struct OutgoingMsgStruct))); _MEMCHECK(m);}
 
 /******************************************************************************
  *
@@ -1168,6 +1172,7 @@ int    log_wrap;
 static void log_init()
 {
   log = (logent)malloc(50000 * sizeof(struct logent));
+  _MEMCHECK(log);
   log_pos = 0;
   log_wrap = 0;
 }
@@ -1380,6 +1385,7 @@ int CmiRankOf(int pe)      { return pe - (nodes_by_pe[pe]->nodestart); }
 CmiNodeLock CmiCreateLock()
 {
   CmiNodeLock lk = (CmiNodeLock)malloc(sizeof(mutex_t));
+  _MEMCHECK(lk);
   mutex_init(lk,0,0);
   return lk;
 }
@@ -1504,6 +1510,7 @@ int CmiRankOf(int pe)      { return pe - (nodes_by_pe[pe]->nodestart); }
 CmiNodeLock CmiCreateLock()
 {
   CmiNodeLock lk = (CmiNodeLock)malloc(sizeof(pthread_mutex_t));
+  _MEMCHECK(lk);
   pthread_mutex_init(lk,(pthread_mutexattr_t *)0);
   return lk;
 }
@@ -1751,6 +1758,7 @@ static void ctrl_getone()
       msg[CmiMsgHeaderSizeBytes+len+size] = '\0';
       if(CpvAccess(stateAvailable) == 0){
        CcsRequest qmsg = (CcsRequest)malloc(sizeof(struct CcsRequestNode));
+        _MEMCHECK(qmsg);
        qmsg->ptr = msg;
        qmsg->pe = pe;
        FIFO_EnQueue(CpvAccess(CcsRequestQueue), qmsg);
@@ -1851,6 +1859,7 @@ static void node_addresses_store(addrs) char *addrs;
   p = skipblanks(p);
   if (*p!=0) KillEveryoneCode(82283);
   bype = (OtherNode*)malloc(Cmi_numpes * sizeof(OtherNode));
+  _MEMCHECK(bype);
   for (i=0; i<Cmi_numnodes; i++) {
     OtherNode node = ntab + i;
     node->sent_msgs = 0;
@@ -2840,6 +2849,7 @@ void ConverseInitPE()
   CmiState cs = CmiGetState();
   CpvInitialize(char *, internal_printf_buffer);
   CpvAccess(internal_printf_buffer) = (char *) malloc(PRINTBUFSIZE);
+  _MEMCHECK(CpvAccess(internal_printf_buffer));
   CthInit(Cmi_argv);
 #if CMK_CCS_AVAILABLE
   CpvInitialize(void *, CcsRequestQueue);
index a05495b3407fd276eb6ca92ef86f6e85c2eab1ab..bb6895cb419d1bbde989807efe2e5b7a9d020cb6 100644 (file)
@@ -29,11 +29,13 @@ class Chare {
     virtual ~Chare() { removeObject(this); }
     virtual char *showHeader(void) {
       char *ret = (char *)malloc(strlen("Default Header")+1);
+      _MEMCHECK(ret);
       strcpy(ret,"Default Header");
       return ret;
     }
     virtual char *showContents(void) {
       char *ret = (char *)malloc(strlen("Default Content")+1);
+      _MEMCHECK(ret);
       strcpy(ret,"Default Content");
       return ret;
     }
index 50b5b7f8b28a136d3c1806f2213f7938e6159680..221db1e5a1ebc1d5a00d1f3781fe450ecdbe19a6 100644 (file)
@@ -43,7 +43,9 @@ CkGroupID CkGetNodeGroupID(void) {
 
 static inline void *_allocNewChare(envelope *env)
 {
-  return malloc(_chareTable[_entryTable[env->getEpIdx()]->chareIdx]->size);
+  void *tmp=malloc(_chareTable[_entryTable[env->getEpIdx()]->chareIdx]->size);
+  _MEMCHECK(tmp);
+  return tmp;
 }
  
 static void _processNewChareMsg(envelope *env)
@@ -344,6 +346,7 @@ void CkCreateChare(int cIdx, int eIdx, void *msg, CkChareID *pCid, int destPE)
   } else {
     pCid->onPE = (-(CkMyPe()+1));
     pCid->objPtr = (void *) new VidBlock();
+    _MEMCHECK(pCid->objPtr);
     env->setMsgtype(NewVChareMsg);
     env->setVidPtr(pCid->objPtr);
   }
@@ -365,6 +368,7 @@ void _createGroupMember(CkGroupID groupID, int eIdx, void *msg)
 {
   register int gIdx = _entryTable[eIdx]->chareIdx;
   register void *obj = malloc(_chareTable[gIdx]->size);
+  _MEMCHECK(obj);
   CpvAccess(_groupTable)->add(groupID, obj);
   register void *prev = CpvAccess(_currentChare);
   CpvAccess(_currentChare) = obj;
@@ -381,6 +385,7 @@ void _createNodeGroupMember(CkGroupID groupID, int eIdx, void *msg)
 {
   register int gIdx = _entryTable[eIdx]->chareIdx;
   register void *obj = malloc(_chareTable[gIdx]->size);
+  _MEMCHECK(obj);
   CmiLock(_nodeLock);
   _nodeGroupTable->add(groupID, obj);
   CmiUnlock(_nodeLock);
index 5ccc135977116909259201b11eade4248ab674c2..e114512e430d4927ef2701bec4b59a44acd3d830 100644 (file)
@@ -28,7 +28,7 @@ class VidBlock {
     PtrQ *msgQ;
     CkChareID actualID;
   public:
-    VidBlock() { state = UNFILLED; msgQ = new PtrQ(); }
+    VidBlock() { state = UNFILLED; msgQ = new PtrQ(); _MEMCHECK(msgQ); }
     void send(envelope *env) {
       if(state==UNFILLED) {
         msgQ->enq((void *)env);
index 2cabdacfcbc868db91d71c5e1c7a2d981910903c..4975bbe77c36361a9667e81440b8ae267011f10a 100644 (file)
@@ -87,6 +87,7 @@ void Array1D::RecvMapID(ArrayMap *mPtr, CkChareID mHandle,
   mapGroup = mGroup;
 
   elementIDs = new ElementIDs[numElements];
+  _MEMCHECK(elementIDs);
   elementIDsReported = 0;
   numLocalElements=0;
   int i;
index b104a619e8e6513166f5b3c1774f1ec5e6554edb..c879f44fad3246c959c5492130ee695210ec4883 100644 (file)
@@ -115,6 +115,7 @@ void _futuresModuleInit(void)
 {
   CpvInitialize(FutureState, futurestate);
   CpvAccess(futurestate).array = (Future *)malloc(10*sizeof(Future));
+  _MEMCHECK(CpvAccess(futurestate).array);
   CpvAccess(futurestate).max   = 10;
   CpvAccess(futurestate).freelist = -1;
   addedFutures(0,10);
index 49e26e71286cf5a34a3ca62c457a373327f1f7f4..5587e0a02b9c1551e27650afb50df680db36e504 100644 (file)
@@ -100,6 +100,7 @@ char* genericViewMsgFunction(char *msg, int type){
   if(f == 0){
     // Undefined Content/Header function
     temp = (char *)malloc(strlen(HeaderUnknownFormat)+1);
+    _MEMCHECK(temp);
     strcpy(temp, HeaderUnknownFormat);
     return(temp);
   } else{
@@ -121,6 +122,7 @@ char* getMsgListSched(void)
   }
   maxLength = ending * sizeof(char) * 20 + 1;
   list = (char *)malloc(maxLength);
+  _MEMCHECK(list);
   strcpy(list, "");
 
   for(int i = schedIndex; i < ending + schedIndex; i++){
@@ -148,6 +150,7 @@ char* getMsgListPCQueue(void)
   char *list;
 
   list = (char *)malloc(strlen(NotImpl)+1);
+  _MEMCHECK(list);
   strcpy(list, NotImpl);
   return(list);
 }
@@ -167,6 +170,7 @@ char* getMsgListFIFO(void)
   }
   maxLength = ending * sizeof(char) * 20 + 1;
   list = (char *)malloc(maxLength);
+  _MEMCHECK(list);
   strcpy(list, "");
 
   for(int i=FIFOIndex; i < FIFOIndex+ending; i++){
@@ -202,6 +206,7 @@ char* getMsgListDebug(void)
   }
   maxLength = ending * sizeof(char) * 20 + 1;
   list = (char *)malloc(maxLength);
+  _MEMCHECK(list);
   strcpy(list, "");
 
   if(DQueue != 0) free(DQueue);
@@ -234,6 +239,7 @@ char* getMsgContentsPCQueue(int index)
 {
   char *temp;
   temp = (char *)malloc(strlen(NotImpl)+1);
+  _MEMCHECK(temp);
   strcpy(temp, NotImpl);
   return(temp);
 }
index 677477a51ad1933e1856f995f29dca80e5032f93..640d00142002e249f360005247eea0c587bd6c15 100644 (file)
@@ -57,6 +57,7 @@ void HashTable::putObject(Chare* charePtr)
   
   chareIndex = (size_t)charePtr;
   node = (struct HashTableElement *)malloc(sizeof(struct HashTableElement));
+  _MEMCHECK(node);
   node->charePtr = charePtr;
   node->chareIndex = chareIndex;
   pigeonHole = chareIndex % PRIME;
@@ -100,6 +101,7 @@ char* HashTable::getObjectList(void)
   int maxLength = PRIME * 20 * sizeof(char);
   
   list = (char *)malloc(maxLength);
+  _MEMCHECK(list);
   strcpy(list, "");
   for(int i = 0; i < PRIME; i++){
     node = array[i];
@@ -110,6 +112,7 @@ char* HashTable::getObjectList(void)
          maxLength *= 2;
          oldlist = list;
          list = (char *)malloc(maxLength);
+          _MEMCHECK(list);
          strcpy(list, oldlist);
          free(oldlist);
        }
@@ -144,6 +147,7 @@ extern "C"
 void CpdInitializeObjectTable(void)
 {
   objectTable = new HashTable();
+  _MEMCHECK(objectTable);
 }
 
 #endif
index 7785db422c4202ad51e3d14abddb43494b256d78..622407f693aa8ed03460c25fd430f94e7aa06903 100644 (file)
@@ -22,6 +22,7 @@ char *makeSymbolTableInfo(void)
   int i;
 
   returnInfo = (char *)malloc(1);
+  _MEMCHECK(returnInfo);
   returnInfo[0] = '\0';
   for(i = 0; i < MAX_NUM_HANDLERS; i++){
     if((f = CpvAccess(SymbolTableFnArray)[i]) != 0){
@@ -29,6 +30,7 @@ char *makeSymbolTableInfo(void)
 
       p = (*f)();
       newReturnInfo = (char *)malloc(strlen(p) + strlen(returnInfo) + 1);
+      _MEMCHECK(newReturnInfo);
       strcpy(newReturnInfo, returnInfo);
       strcat(newReturnInfo, p);
       free(returnInfo);
@@ -94,11 +96,13 @@ char *getBreakPoints(void)
   if(CsvAccess(BreakPoints) == 0){
     CsvAccess(BreakPoints) = (int *)malloc(CpvAccess(numBreakPoints) 
                                           *sizeof(int));
+    _MEMCHECK(CsvAccess(BreakPoints));
     for(i = 0; i < CpvAccess(numBreakPoints); i++)
       CsvAccess(BreakPoints)[i] = 0;
   }
 
   temp = (char *)malloc(CpvAccess(numBreakPoints)*2*sizeof(char)+6);
+  _MEMCHECK(temp);
   strcpy(temp, "");
   sprintf(temp, "%d#", CpvAccess(numBreakPoints));
   for(i = 0; i < CpvAccess(numBreakPoints); i++){
@@ -117,6 +121,7 @@ int isBreakPoint(char *msg)
   if(CsvAccess(BreakPoints) == 0){
     CsvAccess(BreakPoints) = (int *)malloc(CpvAccess(numBreakPoints)
                                           *sizeof(int));
+    _MEMCHECK(CsvAccess(BreakPoints));
     for(i = 0; i < CpvAccess(numBreakPoints); i++)
       CsvAccess(BreakPoints)[i] = 0;
   }
index e6273bb136c18bb6f48198aaa2907fc928438d1b..c1c681bd2a5b6624bde8fd5fa976e7a61a31b8d0 100644 (file)
@@ -110,6 +110,7 @@ static inline void _printStats(void)
   int i;
   if(_printSS || _printCS) {
     Stats *total = new Stats();
+    _MEMCHECK(total);
     for(i=0;i<CkNumPes();i++)
       total->combine(_allStats[i]);
     CkPrintf("Charm Kernel Summary Statistics:\n");
@@ -357,6 +358,7 @@ char* getEnvInfo(envelope *env)
   size += strlen(_chareTable[chareIndex]->name)+1;
   
   returnInfo = (char *)malloc((size + 2) * sizeof(char));
+  _MEMCHECK(returnInfo);
   strcpy(returnInfo, _entryTable[epIndex]->name);
   strcat(returnInfo, "%");
   strcat(returnInfo, _chareTable[chareIndex]->name);
@@ -372,6 +374,7 @@ char* makeCharmSymbolTableInfo(void)
    
   size = _numEntries * 100;
   returnInfo = (char *)malloc(size * sizeof(char));
+  _MEMCHECK(returnInfo);
   strcpy(returnInfo, "");
   for(i = 0; i < _numEntries; i++){
     strcat(returnInfo, "EP : ");
@@ -408,6 +411,7 @@ static char* fContent(char *msg)
   char *temp;
 
   temp = (char *)malloc(strlen(_contentStr) + 1);
+  _MEMCHECK(temp);
   strcpy(temp, _contentStr);
   return(temp);
 }
@@ -432,19 +436,27 @@ void _initCharm(int argc, char **argv)
   CpvInitialize(Stats*, _myStats);
 
   CpvAccess(_buffQ) = new PtrQ();
+  _MEMCHECK(CpvAccess(_buffQ));
   CpvAccess(_bocInitQ) = new PtrQ();
+  _MEMCHECK(CpvAccess(_bocInitQ));
   CpvAccess(_nodeBocInitQ) = new PtrQ();
+  _MEMCHECK(CpvAccess(_nodeBocInitQ));
   CpvAccess(_groupTable) = new GroupTable();
+  _MEMCHECK(CpvAccess(_groupTable));
   if(CmiMyRank()==0) {
     _nodeLock = CmiCreateLock();
     _nodeGroupTable = new GroupTable();
+    _MEMCHECK(_nodeGroupTable);
   }
   CmiNodeBarrier();
   CpvAccess(_qd) = new QdState();
+  _MEMCHECK(CpvAccess(_qd));
   CpvAccess(_numInitsRecd) = 0;
 
   CpvAccess(_ckout) = new _CkOutStream();
+  _MEMCHECK(CpvAccess(_ckout));
   CpvAccess(_ckerr) = new _CkErrStream();
+  _MEMCHECK(CpvAccess(_ckerr));
 
   _charmHandlerIdx = CmiRegisterHandler((CmiHandler)_bufferHandler);
   _initHandlerIdx = CmiRegisterHandler((CmiHandler)_initHandler);
@@ -477,14 +489,18 @@ void _initCharm(int argc, char **argv)
   }
   _TRACE_BEGIN_COMPUTATION();
   CpvAccess(_myStats) = new Stats();
+  _MEMCHECK(CpvAccess(_myStats));
   CpvAccess(_msgPool) = new MsgPool();
+  _MEMCHECK(CpvAccess(_msgPool));
   CmiNodeBarrier();
   if(CmiMyPe()==0) {
     _allStats = new Stats*[CkNumPes()];
+    _MEMCHECK(_allStats);
     register int i;
     for(i=0;i<_numMains;i++) {
       register int size = _chareTable[_mainTable[i]->chareIdx]->size;
       register void *obj = malloc(size);
+      _MEMCHECK(obj);
       CpvAccess(_currentChare) = obj;
       register CkArgMsg *msg = (CkArgMsg *)CkAllocMsg(0, sizeof(CkArgMsg), 0);
       msg->argc = argc;
index 7f720b893a19cf7c0c0e30f1a501d40e07938b0c..2ddbc64b10004aeffa14898435ff716531092002 100644 (file)
@@ -10,6 +10,7 @@ class PtrQ {
   public:
     PtrQ() :len(0), first(0) {
       block = new void*[blklen=BLKSZ];
+      _MEMCHECK(block);
     }
     ~PtrQ() { delete[] block; }
     int length(void) { return len; }
@@ -25,6 +26,7 @@ class PtrQ {
     void enq(void *elt) {
       if(len==blklen) {
         void **newblk = new void*[blklen+BLKSZ];
+        _MEMCHECK(newblk);
         memcpy(newblk, block+first, sizeof(void*)*(blklen-first));
         memcpy(newblk+blklen-first, block, sizeof(void*)*first);
         delete[] block; block = newblk;
@@ -55,6 +57,7 @@ class GroupTable {
     void add(CkGroupID n, void *obj) {
       int slot = n%MAXBINS;
       bins[slot] = new TableEntry(n, obj, bins[slot]);
+      _MEMCHECK(bins[slot]);
     }
     void *find(CkGroupID n) {
       TableEntry *next = bins[n%MAXBINS];
index 707da7a910a163ab7d62991346a59233819b2ea0..5d9cdf769aed41c074cc1947ab9dc46ea83ab088 100644 (file)
@@ -31,8 +31,11 @@ static inline void _bcastQD2(QdState* state, QdMsg *msg)
 static inline void _handlePhase0(QdState *state, QdMsg *msg)
 {
   assert(CkMyPe()==0 || state->getStage()==0);
-  if(CkMyPe()==0)
-    state->enq(new QdCallback(msg->getEp(), msg->getCid()));
+  if(CkMyPe()==0) {
+    QdCallback *qdcb = new QdCallback(msg->getEp(), msg->getCid());
+    _MEMCHECK(qdcb);
+    state->enq(qdcb);
+  }
   if(state->getStage()==0)
     _bcastQD1(state, msg);
   else
index 374d57713b84469631c4803669452754f719e99a..b8f14bca00145bda4da935c79e1b232c1fd39121 100644 (file)
@@ -52,9 +52,11 @@ class QdState {
       cCreated = 0; cProcessed = 0; cDirty = 0;
       oProcessed = 0;
       callbacks = new PtrQ();
+      _MEMCHECK(callbacks);
       nChildren = CmiNumSpanTreeChildren(CkMyPe());
       parent = CmiSpanTreeParent(CkMyPe());
       children = new int[nChildren];
+      _MEMCHECK(children);
       CmiSpanTreeChildren(CkMyPe(), children);
     }
     void propagate(QdMsg *msg) {
index efd875e2584081c04daa2a6e120fb8d4231655e2..1dc92bfcda8277fa8bb0337f29e7cdbe4283b468 100644 (file)
@@ -23,11 +23,17 @@ void _registerInit(void)
   _numReadonlies = 0;
   _numReadonlyMsgs = 0;
   _entryTable = new EntryInfo*[_ENTRY_TABLE_SIZE];
+  _MEMCHECK(_entryTable);
   _msgTable = new MsgInfo*[_MSG_TABLE_SIZE];
+  _MEMCHECK(_msgTable);
   _chareTable = new ChareInfo*[_CHARE_TABLE_SIZE];
+  _MEMCHECK(_chareTable);
   _mainTable = new MainInfo*[_MAIN_TABLE_SIZE];
+  _MEMCHECK(_mainTable);
   _readonlyTable = new ReadonlyInfo*[_READONLY_TABLE_SIZE];
+  _MEMCHECK(_readonlyTable);
   _readonlyMsgs = new ReadonlyMsgInfo*[_READONLY_TABLE_SIZE];;
+  _MEMCHECK(_readonlyMsgs);
 }
 
 extern "C"
@@ -35,6 +41,7 @@ int CkRegisterMsg(const char *name, CkPackFnPtr pack, CkUnpackFnPtr unpack,
                   CkCoerceFnPtr coerce, int size)
 {
   _msgTable[_numMsgs] = new MsgInfo(name, pack, unpack, coerce, size);
+  _MEMCHECK(_msgTable[_numMsgs]);
   return _numMsgs++;
 }
 
@@ -42,6 +49,7 @@ extern "C"
 int CkRegisterEp(const char *name, CkCallFnPtr call, int msgIdx, int chareIdx)
 {
   _entryTable[_numEntries] = new EntryInfo(name, call, msgIdx, chareIdx);
+  _MEMCHECK(_entryTable[_numEntries]);
   return _numEntries++;
 }
 
@@ -49,6 +57,7 @@ extern "C"
 int CkRegisterChare(const char *name, int dataSz)
 {
   _chareTable[_numChares] = new ChareInfo(name, dataSz);
+  _MEMCHECK(_chareTable[_numChares]);
   return _numChares++;
 }
 
@@ -56,20 +65,26 @@ extern "C"
 int CkRegisterMainChare(int chareIdx, int entryIdx)
 {
   _mainTable[_numMains] = new MainInfo(chareIdx, entryIdx);
+  _MEMCHECK(_mainTable[_numMains]);
   return _numMains++;
 }
 
 extern "C"
 void CkRegisterReadonly(int size, void *ptr)
 {
-  _readonlyTable[_numReadonlies++] = new ReadonlyInfo(size, ptr);
+  _readonlyTable[_numReadonlies] = new ReadonlyInfo(size, ptr);
+  _MEMCHECK(_readonlyTable[_numReadonlies]);
+  _numReadonlies++;
   return;
 }
 
 extern "C"
 void CkRegisterReadonlyMsg(void **pMsg)
 {
-  _readonlyMsgs[_numReadonlyMsgs++] = new ReadonlyMsgInfo(pMsg);
+  _readonlyMsgs[_numReadonlyMsgs] = new ReadonlyMsgInfo(pMsg);
+  _MEMCHECK(_readonlyMsgs[_numReadonlyMsgs]);
+  _numReadonlyMsgs++;
+  return;
 }
 
 // temporarily here for satisfying NAMD, it should go to tracing module
index 6b2b26089a517fd5aa7ad40ca96dad2934cab1bb..ab8a93804e60c21d3b82160c492b8aa6894cac6e 100644 (file)
@@ -238,6 +238,7 @@ TempoArray::ckTempoReduce(int root, int op, void *inbuf, void *outbuf,
   if(thisIndex==root) {
     memcpy(outbuf, inbuf, size);
     void *tbuf = malloc(size);
+    _MEMCHECK(tbuf);
     for(int i=0; i<numElements-1; i++) {
       ckTempoRecv(REDUCE_TAG, tbuf, size);
       doOp(op, type, count, tbuf, outbuf);
index d8dbef9dabf829984fdf94518d7b4a3dd0dafc2e..20aad06f7005dea0ae85a38f52134b555b352224 100644 (file)
@@ -50,7 +50,9 @@ void CcdModuleInit(void)
 
    CpvAccess(timerHeap) = 
      (HeapIndexType*) malloc(sizeof(HeapIndexType)*(MAXTIMERHEAPENTRIES + 1));
+   _MEMCHECK(CpvAccess(timerHeap));
    CpvAccess(CondArr) = (CONDS*) malloc(sizeof(CONDS)*(MAXCONDCHKARRAYELTS));
+   _MEMCHECK(CpvAccess(CondArr));
    CpvAccess(CcdNumChecks) = 0;
    CpvAccess(numHeapEntries) = 0;
    CpvAccess(PeriodicCalls) = (FN_ARG *) 0;
@@ -66,6 +68,7 @@ void CcdModuleInit(void)
 void CcdCallOnCondition(int condnum,CcdVoidFn fnp,void *arg)
 {
   FN_ARG *newEntry = (FN_ARG *) malloc(sizeof(FN_ARG)); 
+  _MEMCHECK(newEntry);
   newEntry->fn = fnp;  
   newEntry->arg  = arg;
   newEntry->next = CpvAccess(CondArr)[condnum].fn_arg_list;
@@ -78,6 +81,7 @@ void CcdCallOnCondition(int condnum,CcdVoidFn fnp,void *arg)
 void CcdPeriodicallyCall(CcdVoidFn fnp, void *arg)
 {
   FN_ARG *temp = (FN_ARG *) malloc(sizeof(FN_ARG)); 
+  _MEMCHECK(temp);
   temp->fn = fnp;
   temp->arg = arg;
   temp->next = CpvAccess(PeriodicCalls);
index ec81419a2cf7284ca91e79b14995244225498a32..06541acee6a6c2c5f4be866b7f34e618f1ada5e6 100644 (file)
@@ -253,6 +253,7 @@ static void CmiHandlerInit()
   CpvAccess(CmiHandlerGlobal) = 2;
   CpvAccess(CmiHandlerMax) = 100;
   CpvAccess(CmiHandlerTable) = (CmiHandler *)malloc(100*sizeof(CmiHandler)) ;
+  _MEMCHECK(CpvAccess(CmiHandlerTable));
 }
 
 
@@ -706,7 +707,9 @@ void CHostHandler(char *msg)
 void CHostInit()
 {
   nodeIPs = (unsigned int *)malloc(CmiNumPes() * sizeof(unsigned int));
+  _MEMCHECK(nodeIPs);
   nodePorts = (unsigned int *)malloc(CmiNumPes() * sizeof(unsigned int));
+  _MEMCHECK(nodePorts);
   CpvInitialize(int, CHostHandlerIndex);
   CpvAccess(CHostHandlerIndex) = CmiRegisterHandler(CHostHandler);
 }
@@ -1002,6 +1005,7 @@ static void CpdDebugHandler(char *msg)
       }
       else{
        reply = (char *)malloc(strlen(breakPointHeader) + strlen(breakPointContents) + 1);
+        _MEMCHECK(reply);
        strcpy(reply, breakPointHeader);
        strcat(reply, "@");
        strcat(reply, breakPointContents);
@@ -1099,6 +1103,7 @@ static void sendDataFunction(void)
   len+=6; /* for 'perf ' and the \0 at the end */
 
   reply = (char *)malloc(len * sizeof(char));
+  _MEMCHECK(reply);
   strcpy(reply, "perf ");
 
   for(i=0; i<CmiNumPes(); i++){
@@ -1191,6 +1196,7 @@ static void CWebHandler(char *msg){
       appletPort = port;
 
       valueArray = (char **)malloc(sizeof(char *) * CmiNumPes());
+      _MEMCHECK(valueArray);
       for(i = 0; i < CmiNumPes(); i++)
         valueArray[i] = 0;
 
@@ -1470,6 +1476,7 @@ void CmiHandleMessage(void *msg)
     /* Freeze and send a message back */
     CpdFreeze();
     freezeReply = (char *)malloc(strlen("freezing@")+strlen(breakPointHeader)+1);
+    _MEMCHECK(freezeReply);
     sprintf(freezeReply, "freezing@%s", breakPointHeader);
     fd = skt_connect(freezeIP, freezePort, 120);
     if(fd > 0){
@@ -1499,6 +1506,7 @@ void CmiHandleMessage(void *msg)
     /* Freeze and send a message back */
     CpdFreeze();
     freezeReply = (char *)malloc(strlen("freezing@")+strlen(breakPointHeader)+1);
+    _MEMCHECK(freezeReply);
     sprintf(freezeReply, "freezing@%s", breakPointHeader);
     fd = skt_connect(freezeIP, freezePort, 120);
     if(fd > 0){
@@ -2119,7 +2127,7 @@ int size;
 {
   char *res;
   res =(char *)malloc(size+2*sizeof(int));
-  if (res==0) CmiAbort("Memory allocation failed.");
+  _MEMCHECK(res);
 
 #ifdef MEMMONITOR
   CpvAccess(MemoryUsage) += size+2*sizeof(int);
@@ -2440,11 +2448,13 @@ void CcsUseHandler(char *name, int hdlr)
   CcsListNode *list=CpvAccess(ccsList);
   if(list==0) {
     list = (CcsListNode *)malloc(sizeof(CcsListNode));
+    _MEMCHECK(list);
     CpvAccess(ccsList) = list;
   } else {
     while(list->next != 0) 
       list = list->next;
     list->next = (CcsListNode *)malloc(sizeof(CcsListNode));
+    _MEMCHECK(list->next);
     list = list->next;
   }
   strcpy(list->name, name);
index ceb6e12cfcb8e174eb388ada513199ac979aa385..9047c47b924515c1b8da0777212d2329d9bccbde 100644 (file)
@@ -938,6 +938,12 @@ void ConverseExit(void);
 
 void CmiAbort(const char *);
 
+#ifndef CMK_OPTIMIZE
+#define _MEMCHECK(p) { if ((p)==0) CmiAbort("Memory Allocation Failure.\n"); }
+#else
+#define _MEMCHECK(p)
+#endif
+
 /*********** CPATH ***********/
 
 typedef struct
index 10c06359fcbcea17b60f75b423a6cc2aa6a574cf..2443f51ace1a2ab888896dfd55ebc71981fc0604 100644 (file)
@@ -192,6 +192,7 @@ single CPathGetSingle(CPath *path, int *indices)
   }
   
   result = (single)malloc(sizeof(struct single));
+  _MEMCHECK(result);
   result->path = *path;
   result->eltno = eltno;
   result->waiting = 0;
@@ -636,6 +637,7 @@ reduction CPathGetReduction(eltset set, int ntags, int *tags,
   }
   
   red = (reduction)malloc(sizeof(struct reduction) + ntags*sizeof(int));
+  _MEMCHECK(red);
   
   red->over = set;
   red->ntags = ntags;
@@ -814,4 +816,5 @@ void CPathModuleInit()
   
   CpvAccess(PEflags) = (char*)calloc(1,CmiNumPes());
   CpvAccess(PElist) = (int*)malloc(CmiNumPes()*sizeof(int));
+  _MEMCHECK(CpvAccess(PElist));
 }
index 9a288d150548373b738713d24a8f04bf2ef4fa27..11595cb17b76bfa2b10e9eda265e216b45a71cbf 100644 (file)
@@ -105,6 +105,7 @@ int Cpthread_key_create(Cpthread_key_t *keyp, void (*destructo)(void *))
     keys_inactive = key->next;
   } else {
     key = (Cpthread_key_t)malloc(sizeof(struct Cpthread_key_s));
+    _MEMCHECK(key);
     key->offset = CthRegister(sizeof(void *));
   }
   key->magic = KEY_MAGIC;
@@ -175,6 +176,7 @@ void Cpthread_cleanup_push(void (*routine)(void*), void *arg)
   Cpthread_t pt = CtvAccess(Cpthread_current);
   Cpthread_cleanup_t c =
     (Cpthread_cleanup_t)malloc(sizeof(struct Cpthread_cleanup_s));
+  _MEMCHECK(c);
   c->routine = routine;
   c->argument = arg;
   c->next = pt->cleanups;
@@ -279,6 +281,7 @@ int Cpthread_create3(Cpthread_t *thread, Cpthread_attr_t *attr,
   Cpthread_t pt;
   if (attr->magic != ATTR_MAGIC) errcode(EINVAL);
   pt = (Cpthread_t)malloc(sizeof(struct Cpthread_s));
+  _MEMCHECK(pt);
   pt->magic = PT_MAGIC;
   pt->startfn = fn;
   pt->startarg1 = a1;
index aee7edd78f9c481946bf64df5926cfa942526bb8..f1fc5c80b6a856cc5a7180e5b482025b846c4178 100644 (file)
@@ -7,7 +7,9 @@ FIFO_QUEUE *FIFO_Create(void)
 {
   FIFO_QUEUE *queue;
   queue = (FIFO_QUEUE *)malloc(sizeof(FIFO_QUEUE));
+  _MEMCHECK(queue);
   queue->block = (void **) malloc(_FIFO_BLK_LEN * sizeof(void *));
+  _MEMCHECK(queue->block);
   queue->size = _FIFO_BLK_LEN;
   queue->push = queue->pull = 0;
   queue->fill = 0;
@@ -32,6 +34,7 @@ static void FIFO_Expand(FIFO_QUEUE *queue)
   void **block = queue->block;
   newsize = size * 3;
   newblock = (void**)malloc(newsize * sizeof(void *));
+  _MEMCHECK(newblock);
   rest = size - pull;
   memcpy(newblock, block + pull, rest * sizeof(void *));
   memcpy(newblock + rest, block, pull * sizeof(void *));
@@ -96,6 +99,7 @@ void FIFO_Enumerate(FIFO_QUEUE *queue, void ***element)
   if(num == 0)
     return;
   *element = (void **)malloc(num * sizeof(void *));
+  _MEMCHECK(*element);
   while(num > 0){
     (*element)[i++] = queue->block[pull];
     pull = (pull + 1) % queue->size;
index 390570213a9c04d050d8ef002e5376249e1d8408..66659bda7cdd0b93c2960c5075e74b2ddecae5d4 100644 (file)
@@ -26,6 +26,7 @@ Cfuture CfutureCreate()
 {
   futdata data = (futdata)malloc(sizeof(struct Cfuture_data_s));
   Cfuture result;
+  _MEMCHECK(data);
   data->value = 0;
   data->ready = 0;
   data->waiters = 0;
index e4761eeed41ef83e08dc41d0a91201651ae86482..1914d3073844de4e35f47d6f9f2d6e6af181c1ea 100644 (file)
@@ -159,11 +159,14 @@ void CthPackThread(CthThread t, void *buffer)
 CthThread CthUnpackThread(void *buffer)
 {
   CthThread t = (CthThread) malloc(sizeof(CthThreadStruct));
+  _MEMCHECK(t);
   memcpy((void*) t, buffer, sizeof(CthThreadStruct));
   t->data = (char *) malloc(t->datasize);
+  _MEMCHECK(t->data);
   memcpy((void*)t->data, ((char*)buffer)+sizeof(CthThreadStruct),
          t->datasize);
   t->savedstack = (qt_t*) malloc(t->savedsize);
+  _MEMCHECK(t->savedstack);
   t->stacklen = t->savedsize;
   memcpy((void*)t->savedstack, 
          ((char*)buffer)+sizeof(CthThreadStruct)+t->datasize, t->savedsize);
@@ -222,6 +225,7 @@ void CthFixData(CthThread t)
   if (t->data == 0) {
     t->datasize = datasize;
     t->data = (char *)malloc(datasize);
+    _MEMCHECK(t->data);
     return;
   }
   if (t->datasize != datasize) {
@@ -259,7 +263,9 @@ void CthInit()
   CthCpvInitialize(CthProcInfo, CthProc);
 
   t = (CthThread)malloc(sizeof(struct CthThreadStruct));
+  _MEMCHECK(t);
   p = (CthProcInfo)malloc(sizeof(struct CthProcInfo));
+  _MEMCHECK(p);
   CthThreadInit(t,0,0);
   CthCpvAccess(CthData)=0;
   CthCpvAccess(CthProc)=p;
@@ -269,6 +275,7 @@ void CthInit()
   p->current = t;
   p->datasize = 0;
   switchbuf = (qt_t*)malloc(QT_STKALIGN + SWITCHBUF_SIZE);
+  _MEMCHECK(switchbuf);
   switchbuf = (qt_t*)((((size_t)switchbuf)+QT_STKALIGN) & ~(QT_STKALIGN-1));
   p->switchbuf = switchbuf;
   sp = QT_SP(switchbuf, SWITCHBUF_SIZE);
@@ -307,6 +314,7 @@ static void CthResume1(qt_t *sp, CthProcInfo proc, CthThread t)
     if(bytes > old->stacklen) {
       if(old->savedstack) free((void *)old->savedstack);
       old->savedstack = (qt_t*)malloc(bytes);
+      _MEMCHECK(old->savedstack);
       old->stacklen = bytes;
     }
     old->savedsize = bytes;
@@ -344,6 +352,7 @@ CthThread CthCreate(fn, arg, size)
 CthVoidFn fn; void *arg; int size;
 {
   CthThread result = (CthThread)malloc(sizeof(struct CthThreadStruct));
+  _MEMCHECK(result);
   CthThreadInit(result, fn, arg);
   return result;
 }
@@ -503,6 +512,7 @@ CthThread t;
   if (t->data == 0) {
     t->datasize = datasize;
     t->data = (char *)malloc(datasize);
+    _MEMCHECK(t->data);
     return;
   }
   if (t->datasize != datasize) {
@@ -522,6 +532,7 @@ void CthInit()
   CthCpvInitialize(int,        CthExiting);
 
   t = (CthThread)malloc(sizeof(struct CthThreadStruct));
+  _MEMCHECK(t);
   t->protect = 0;
   t->protlen = 0;
   CthThreadInit(t);
@@ -596,8 +607,9 @@ CthVoidFn fn; void *arg; int size;
   if (size==0) size = STACKSIZE;
   size = (size+(CMK_MEMORY_PAGESIZE*2)-1) & ~(CMK_MEMORY_PAGESIZE-1);
   stack = (qt_t*)CthMemAlign(CMK_MEMORY_PAGESIZE, size);
+  _MEMCHECK(stack);
   result = (CthThread)malloc(sizeof(struct CthThreadStruct));
-  if ((stack==0)||(result==0)) { CmiError("Out of memory."); exit(1); }
+  _MEMCHECK(result);
   CthThreadInit(result);
   stackbase = QT_SP(stack, size);
   stackp = QT_ARGS(stackbase, arg, result, (qt_userf_t *)fn, CthOnly);