ck-core #188: replace Cmi{Bool,False,True} with {bool,false,true}
authorRamprasad Venkataraman <ramv@illinois.edu>
Tue, 23 Apr 2013 18:42:17 +0000 (13:42 -0500)
committerRamprasad Venkataraman <ramv@illinois.edu>
Wed, 24 Apr 2013 19:39:23 +0000 (14:39 -0500)
43 files changed:
examples/charm++/Maj_Min/jacobi2d.C
examples/charm++/barnes-charm/ParticleChunk.cpp
examples/charm++/barnes-charm/TreePiece.cpp
examples/charm++/jacobi2d-sdag/jacobi2d.C
examples/charm++/jacobi3d-sdag/jacobi3d.C
examples/charm++/leanmd/Cell.C
examples/charm++/leanmd/Compute.C
examples/charm++/load_balancing/kNeighbor/kNeighbor.C
examples/charm++/load_balancing/stencil3d/stencil3d.C
examples/charm++/mpi-coexist/libs/kNeighbor/kNeighbor.C
src/ck-core/charm++.h
src/ck-core/ck.C
src/ck-core/ck.h
src/ck-core/ckarray.C
src/ck-core/ckarray.ci
src/ck-core/ckarray.h
src/ck-core/ckarrayindex.h
src/ck-core/ckcallback.C
src/ck-core/ckcallback.h
src/ck-core/ckcausalmlog.C
src/ck-core/ckcausalmlog.h
src/ck-core/ckcheckpoint.C
src/ck-core/ckcheckpoint.h
src/ck-core/ckevacuation.C
src/ck-core/cklocation.C
src/ck-core/cklocation.h
src/ck-core/ckmemcheckpoint.C
src/ck-core/ckmessagelogging.C
src/ck-core/ckmessagelogging.h
src/ck-core/ckreduction.C
src/ck-core/ckreduction.h
src/ck-core/debug-charm.C
src/ck-core/debug-charm.h
src/ck-core/register.C
src/ck-core/register.h
tests/charm++/commtest/comlib/bench.C
tests/charm++/commtest/comlib/benchmulti.C
tests/charm++/commtest/comlib/benchsectionmulti.C
tests/charm++/jacobi3d-gausssiedel/jacobi3d.C
tests/charm++/jacobi3d-gausssiedel/jacobi3d.cc
tests/charm++/jacobi3d-sdag/jacobi3d.C
tests/charm++/jacobi3d/jacobi3d.C
tests/charm++/load_balancing/lb_test/lb_test.C

index c46eb66e2dac35f354d6722fd332dab13424eaa2..98aac793b7b188da9cf64ec9610ca54130350323 100644 (file)
@@ -214,7 +214,7 @@ public:
       arr = new float[1000];
     for (int i = 0; i < 1000; i++)
         arr[i] = rand ();
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
       iterations = 0;
     // allocate two dimensional array
   }
@@ -353,7 +353,7 @@ public:
       arr = new float[1000];
     for (int i = 0; i < 1000; i++)
         arr[i] = rand ();
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
       iterations = 0;
     // allocate two dimensional array
   }
index dbb253ae3bd6b27d8325357433ecc3d5c24efa29..d06cf9a68d41888c0450004159f1b237e498f4a0 100644 (file)
@@ -3,7 +3,7 @@
 #include "barnes.decl.h"
 ParticleChunk::ParticleChunk(int mleaf, int mcell){
 
-  usesAtSync = CmiTrue;
+  usesAtSync = true;
 
   nstep = 0;
   numMsgsToEachTp = new int[numTreePieces];
index 4378e8e5b77c329a43f195c68a7357ac8e199b9d..65b530bef376a7e4da277fe500ffa482e82a3af7 100644 (file)
@@ -4,7 +4,7 @@ TreePiece::TreePiece(CmiUInt8 p_, int which, int level_,  real rx, real ry, real
   nodeptr p;
   isTopLevel = false;
 
-  usesAtSync = CmiFalse;
+  usesAtSync = false;
   setMigratable(false);
   
   rmin[0] = rx;
@@ -62,7 +62,7 @@ TreePiece::TreePiece(CmiUInt8 p_, int which, int level_, CkArrayIndex1D parentId
   // acceptroots
   whichChildAmI = thisIndex%NSUB;
 
-  usesAtSync = CmiFalse;
+  usesAtSync = false;
   setMigratable(false);
 
   mycelltab.reserve(maxmycell);
index 15d28c9eb81980926ea67963f543a7dffc6e53ae..7e3c3932bd0cec3550bbcffb693490b1a2d10caf 100644 (file)
@@ -135,7 +135,7 @@ class Jacobi: public CBase_Jacobi {
   bool leftBound, rightBound, topBound, bottomBound;
   // Constructor, initialize values
   Jacobi() {
-    usesAtSync=CmiTrue;
+    usesAtSync=true;
 
     int i, j;
     // allocate a two dimensional array
index 500100b68ff8625ecfdc90b11c8f487bac0f4cb0..21c43ad0b2b5329bc93884073c1aeb69d3e53aab 100644 (file)
@@ -118,7 +118,7 @@ public:
 
   // Constructor, initialize values
   Jacobi() {
-    usesAtSync = CmiTrue;
+    usesAtSync = true;
     converged = false;
 
     // allocate a three dimensional array
index 0f0c5f2ddd3e3597446144c774f36f483d2d2aef..a07be0a0953c08afea3fa34fb4547f4f3be8ea9d 100644 (file)
@@ -19,7 +19,7 @@ Cell::Cell() {
   int i;
   inbrs = NUM_NEIGHBORS;
   //load balancing to be called when AtSync is called
-  usesAtSync = CmiTrue;
+  usesAtSync = true;
 
   int myid = thisIndex.x + thisIndex.y*cellArrayDimX + thisIndex.z*cellArrayDimX*cellArrayDimY;
   myNumParts = PARTICLES_PER_CELL_START + (myid*(PARTICLES_PER_CELL_END-PARTICLES_PER_CELL_START))/(cellArrayDimX*cellArrayDimY*cellArrayDimZ);
@@ -51,7 +51,7 @@ Cell::Cell() {
 
 //constructor for chare object migration
 Cell::Cell(CkMigrateMessage *msg): CBase_Cell(msg) {
-  usesAtSync = CmiTrue;
+  usesAtSync = true;
   delete msg;
 }  
 
index ad26c8e858d3480cefe1c1790da9aa37631ad95a..63d64be612105ca7343dfe727b26d6e273f82980 100644 (file)
@@ -17,11 +17,11 @@ extern /* readonly */ int finalStepCount;
 //compute - Default constructor
 Compute::Compute() {
   stepCount = 1;
-  usesAtSync = CmiTrue;
+  usesAtSync = true;
 }
 
 Compute::Compute(CkMigrateMessage *msg): CBase_Compute(msg)  { 
-  usesAtSync = CmiTrue;
+  usesAtSync = true;
   delete msg;
 }
 
index 6d3ad974ca6cf9dfd839d375f6af554f2c417848..900330cbb6e5b17f6813d6d2c68a987513f34dce 100644 (file)
@@ -185,7 +185,7 @@ class Block: public CBase_Block {
   public:
     Block() {
       //srand(thisIndex.x+thisIndex.y);
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
 
       numNeighbors = 2*STRIDEK;
       neighbors = new int[numNeighbors];
index 1bb135827c80605b7a3f315ca5098485ac2411cb..ea384b44b2a0b6ea26c6ea3d50ff8f29533914c3 100644 (file)
@@ -148,7 +148,7 @@ class Stencil: public CBase_Stencil {
 
     // Constructor, initialize values
     Stencil() {
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
 
       int i, j, k;
       // allocate a three dimensional array
index b5c13553ba1dde3354a4b2bb23123113acec70eb..824df5974ae47180c9fd1490867187408dd98700 100644 (file)
@@ -167,7 +167,7 @@ class Block: public CBase_Block {
   public:
     Block() {
       //srand(thisIndex.x+thisIndex.y);
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
 
       numNeighbors = 2*STRIDEK;
       neighbors = new int[numNeighbors];
index dccbc8d78a29d95bb27cd7c36e8557784c1f5446..49b48e368e6e8ca12b3d4ff99da17d0c95290f48 100644 (file)
@@ -272,9 +272,9 @@ class IrrGroup : public Chare {
 
     // Silly run-time type information
     virtual int isNodeGroup() { return 0; };
-    virtual CmiBool isLocMgr(void){ return CmiFalse; }
-    virtual CmiBool isArrMgr(void){ return CmiFalse; }
-    virtual CmiBool isReductionMgr(void){ return CmiFalse; }
+    virtual bool isLocMgr(void){ return false; }
+    virtual bool isArrMgr(void){ return false; }
+    virtual bool isReductionMgr(void){ return false; }
     static int isIrreducible(){ return 1;}
     virtual void flushStates() {}
                /*
index a8cb5aae6d0481878775d73d75a769ac88dd7098..788cc04b06bb208f3a7440d2b7d0716697578ea8 100644 (file)
@@ -2156,7 +2156,7 @@ private:
     fprintf(f, "%s", buffer);
     curpos=0;
   }
-  virtual CmiBool process(envelope **envptr,CkCoreState *ck) {
+  virtual bool process(envelope **envptr,CkCoreState *ck) {
     if ((*envptr)->getEvent()) {
       bool wasPacked = (*envptr)->isPacked();
       if (!wasPacked) CkPackMessage(envptr);
@@ -2174,15 +2174,15 @@ private:
       if (curpos > _recplay_logsize-128) flushLog();
       if (!wasPacked) CkUnpackMessage(envptr);
     }
-    return CmiTrue;
+    return true;
   }
-  virtual CmiBool process(CthThreadToken *token,CkCoreState *ck) {
+  virtual bool process(CthThreadToken *token,CkCoreState *ck) {
     curpos+=sprintf(&buffer[curpos], "%d %d %d\n",CkMyPe(), -2, token->serialNo);
     if (curpos > _recplay_logsize-128) flushLog();
-    return CmiTrue;
+    return true;
   }
   
-  virtual CmiBool process(LBMigrateMsg **msg,CkCoreState *ck) {
+  virtual bool process(LBMigrateMsg **msg,CkCoreState *ck) {
     FILE *f;
     if (firstOpen) f = openReplayFile("ckreplay_",".lb","w");
     else f = openReplayFile("ckreplay_",".lb","a");
@@ -2193,7 +2193,7 @@ private:
       (*msg)->pup(p);
       fclose(f);
     }
-    return CmiTrue;
+    return true;
   }
 };
 
@@ -2209,7 +2209,7 @@ public:
   }
   ~CkMessageDetailRecorder() {fclose(f);}
 private:
-  virtual CmiBool process(envelope **envptr, CkCoreState *ck) {
+  virtual bool process(envelope **envptr, CkCoreState *ck) {
     bool wasPacked = (*envptr)->isPacked();
     if (!wasPacked) CkPackMessage(envptr);
     envelope *env = *envptr;
@@ -2217,7 +2217,7 @@ private:
     fwrite(&size, 4, 1, f);
     fwrite(env, env->getTotalsize(), 1, f);
     if (!wasPacked) CkUnpackMessage(envptr);
-    return CmiTrue;
+    return true;
   }
 };
 
@@ -2260,22 +2260,22 @@ class CkMessageReplay : public CkMessageWatcher {
                */
                counter++;
        }
-       /// If this is the next message we need, advance and return CmiTrue.
-       CmiBool isNext(envelope *env) {
-               if (nextPE!=env->getSrcPe()) return CmiFalse;
-               if (nextEvent!=env->getEvent()) return CmiFalse;
-               if (nextSize<0) return CmiFalse; // not waiting for a regular message
+       /// If this is the next message we need, advance and return true.
+       bool isNext(envelope *env) {
+               if (nextPE!=env->getSrcPe()) return false;
+               if (nextEvent!=env->getEvent()) return false;
+               if (nextSize<0) return false; // not waiting for a regular message
 #if 1
                if (nextEP != env->getEpIdx()) {
                        CkPrintf("[%d] CkMessageReplay> Message EP changed during replay org: [%d %d %d %d] got: [%d %d %d %d]\n", CkMyPe(), nextPE, nextSize, nextEvent, nextEP, env->getSrcPe(), env->getTotalsize(), env->getEvent(), env->getEpIdx());
-                       return CmiFalse;
+                       return false;
                }
 #endif
 #if ! CMK_BIGSIM_CHARM
                if (nextSize!=env->getTotalsize())
                 {
                        CkPrintf("[%d] CkMessageReplay> Message size changed during replay org: [%d %d %d %d] got: [%d %d %d %d]\n", CkMyPe(), nextPE, nextSize, nextEvent, nextEP, env->getSrcPe(), env->getTotalsize(), env->getEvent(), env->getEpIdx());
-                        return CmiFalse;
+                        return false;
                 }
                if (_recplay_crc || _recplay_checksum) {
                  bool wasPacked = env->isPacked();
@@ -2303,11 +2303,11 @@ class CkMessageReplay : public CkMessageWatcher {
                  if (!wasPacked) CkUnpackMessage(&env);
                }
 #endif
-               return CmiTrue;
+               return true;
        }
-       CmiBool isNext(CthThreadToken *token) {
-         if (nextPE==CkMyPe() && nextSize==-2 && nextEvent==token->serialNo) return CmiTrue;
-         return CmiFalse;
+       bool isNext(CthThreadToken *token) {
+         if (nextPE==CkMyPe() && nextSize==-2 && nextEvent==token->serialNo) return true;
+         return false;
        }
 
        /// This is a (short) list of messages we aren't yet ready for:
@@ -2364,19 +2364,19 @@ public:
        ~CkMessageReplay() {fclose(f);}
 
 private:
-       virtual CmiBool process(envelope **envptr,CkCoreState *ck) {
+       virtual bool process(envelope **envptr,CkCoreState *ck) {
           bool wasPacked = (*envptr)->isPacked();
           if (!wasPacked) CkPackMessage(envptr);
           envelope *env = *envptr;
          //CkAssert(*(int*)env == 0x34567890);
          REPLAYDEBUG("ProcessMessage message: "<<env->getSrcPe()<<" "<<env->getTotalsize()<<" "<<env->getEvent() <<" " <<env->getMsgtype() <<" " <<env->getMsgIdx() << " ep:" << env->getEpIdx());
-                if (env->getEvent() == 0) return CmiTrue;
+                if (env->getEvent() == 0) return true;
                if (isNext(env)) { /* This is the message we were expecting */
                        REPLAYDEBUG("Executing message: "<<env->getSrcPe()<<" "<<env->getTotalsize()<<" "<<env->getEvent())
                        getNext(); /* Advance over this message */
                        flush(); /* try to process queued-up stuff */
                        if (!wasPacked) CkUnpackMessage(envptr);
-                       return CmiTrue;
+                       return true;
                }
 #if CMK_SMP
                 else if (env->getMsgtype()==NodeBocInitMsg || env->getMsgtype()==ForNodeBocMsg) {
@@ -2386,7 +2386,7 @@ private:
                         if (nextpe == CkNodeFirst(CkMyNode())+CkMyNodeSize())
                         nextpe = CkNodeFirst(CkMyNode());
                         CmiSyncSendAndFree(nextpe,env->getTotalsize(),(char *)env);
-                        return CmiFalse;
+                        return false;
                 }
 #endif
                else /*!isNext(env) */ {
@@ -2394,25 +2394,25 @@ private:
                                <<" because we wanted "<<nextPE<<" "<<nextSize<<" "<<nextEvent << " " << nextEP)
                        delayedMessages.enq(env);
                         flush();
-                       return CmiFalse;
+                       return false;
                }
        }
-       virtual CmiBool process(CthThreadToken *token, CkCoreState *ck) {
+       virtual bool process(CthThreadToken *token, CkCoreState *ck) {
       REPLAYDEBUG("ProcessToken token: "<<token->serialNo);
          if (isNext(token)) {
         REPLAYDEBUG("Executing token: "<<token->serialNo)
            getNext();
            flush();
-           return CmiTrue;
+           return true;
          } else {
         REPLAYDEBUG("Queueing token: "<<token->serialNo
             <<" because we wanted "<<nextPE<<" "<<nextSize<<" "<<nextEvent)
            delayedTokens.enq(token);
-           return CmiFalse;
+           return false;
          }
        }
 
-       virtual CmiBool process(LBMigrateMsg **msg,CkCoreState *ck) {
+       virtual bool process(LBMigrateMsg **msg,CkCoreState *ck) {
          if (lbFile == NULL) lbFile = openReplayFile("ckreplay_",".lb","r");
          if (lbFile != NULL) {
            int num_moves = 0;
@@ -2424,7 +2424,7 @@ private:
            }
            (*msg)->pup(p);
          }
-         return CmiTrue;
+         return true;
        }
 };
 
@@ -2461,10 +2461,10 @@ public:
 
     CcdCallOnCondition(CcdPROCESSOR_STILL_IDLE, (CcdVoidFn)CkMessageDetailReplayDone, (void*)this);
   }
-  virtual CmiBool process(envelope **env,CkCoreState *ck) {
+  virtual bool process(envelope **env,CkCoreState *ck) {
     void *msg = getNext();
     if (msg != NULL) CsdEnqueue(msg);
-    return CmiTrue;
+    return true;
   }
 };
 
@@ -2482,12 +2482,12 @@ extern "C" void CkMessageDetailReplayDone(void *rep, double time) {
   ConverseExit();
 }
 
-static CmiBool CpdExecuteThreadResume(CthThreadToken *token) {
+static bool CpdExecuteThreadResume(CthThreadToken *token) {
   CkCoreState *ck = CkpvAccess(_coreState);
   if (ck->watcher!=NULL) {
     return ck->watcher->processThread(token,ck);
   }
-  return CmiTrue;
+  return true;
 }
 
 CpvCExtern(int, CthResumeNormalThreadIdx);
@@ -2528,7 +2528,7 @@ CpvExtern(int      , CthResumeBigSimThreadIdx);
 #include "ckliststring.h"
 void CkMessageWatcherInit(char **argv,CkCoreState *ck) {
     CmiArgGroup("Charm++","Record/Replay");
-    CmiBool forceReplay = CmiFalse;
+    bool forceReplay = false;
     char *procs = NULL;
     _replaySystem = 0;
     if (CmiGetArgFlagDesc(argv,"+recplay-crc","Enable CRC32 checksum for message record-replay")) {
@@ -2560,7 +2560,7 @@ void CkMessageWatcherInit(char **argv,CkCoreState *ck) {
       ck->addWatcher(new CkMessageRecorder(openReplayFile("ckreplay_",".log","w")));
     }
        if (CmiGetArgStringDesc(argv,"+replay-detail",&procs,"Replay the specified processors from recorded message content")) {
-           forceReplay = CmiTrue;
+           forceReplay = true;
            CpdSetInitializeMemory(1);
            // Set the parameters of the processor
 #if CMK_SHARED_VARS_UNAVAILABLE
index e81734f949433d62a9c4d8e24f2767081aed5141..3a40006b3ba46fb82a1215d6da432d12641414d2 100644 (file)
@@ -139,8 +139,8 @@ public:
         * The message is processed by the watcher starting from the innermost one
         * up to the outermost
         */
-#define PROCESS_MACRO(name,type) inline CmiBool process##name(type *input,CkCoreState *ck) { \
-  CmiBool result = CmiTrue; \
+#define PROCESS_MACRO(name,type) inline bool process##name(type *input,CkCoreState *ck) { \
+  bool result = true; \
     if (next != NULL) result &= next->process##name(input, ck); \
     result &= process(input, ck); \
     return result; \
@@ -153,9 +153,9 @@ public:
 #undef PROCESS_MACRO
 protected:
     /** These are used internally by this class to call the correct subclass method */
-       virtual CmiBool process(envelope **env,CkCoreState *ck) =0;
-       virtual CmiBool process(CthThreadToken *token, CkCoreState *ck) {return CmiTrue;}
-       virtual CmiBool process(LBMigrateMsg **msg, CkCoreState *ck) {return CmiTrue;}
+       virtual bool process(envelope **env,CkCoreState *ck) =0;
+       virtual bool process(CthThreadToken *token, CkCoreState *ck) {return true;}
+       virtual bool process(LBMigrateMsg **msg, CkCoreState *ck) {return true;}
 public:
     inline void setNext(CkMessageWatcher *w) { next = w; }
 };
index bdde0ae526da007d1010a334b49253735dabaa4a..d153cc71605416f50a00a65c3021d2b2a091d4e0 100644 (file)
@@ -105,17 +105,17 @@ public:
 
   ///Element was just created on this processor
   /// Return false if the element migrated away or deleted itself.
-  virtual CmiBool ckElementCreated(ArrayElement *elt)
+  virtual bool ckElementCreated(ArrayElement *elt)
     { return bringUpToDate(elt); }
 
   ///Element just arrived on this processor (so just called pup)
   /// Return false if the element migrated away or deleted itself.
-  virtual CmiBool ckElementArriving(ArrayElement *elt)
+  virtual bool ckElementArriving(ArrayElement *elt)
     { return bringUpToDate(elt); }
 
   void incoming(CkArrayMessage *msg);
 
-  CmiBool deliver(CkArrayMessage *bcast, ArrayElement *el, bool doFree);
+  bool deliver(CkArrayMessage *bcast, ArrayElement *el, bool doFree);
 
   void springCleaning(void);
 
@@ -129,7 +129,7 @@ private:
   bool stableLocations;
   bool broadcastViaScheduler;
 
-  CmiBool bringUpToDate(ArrayElement *el);
+  bool bringUpToDate(ArrayElement *el);
 };
 
 ///This arrayListener is in charge of performing reductions on the array.
@@ -159,8 +159,8 @@ public:
 
   void ckElementLeaving(ArrayElement *elt)
     {mgr->contributorLeaving(getData(elt));}
-  CmiBool ckElementArriving(ArrayElement *elt)
-    {mgr->contributorArriving(getData(elt)); return CmiTrue; }
+  bool ckElementArriving(ArrayElement *elt)
+    {mgr->contributorArriving(getData(elt)); return true; }
 };
 
 /*
@@ -206,10 +206,10 @@ void CkVerboseListener::ckElementCreating(ArrayElement *elt)
 {
   VL_PRINT<<"LIFE  About to create element "<<idx2str(elt)<<endl;
 }
-CmiBool CkVerboseListener::ckElementCreated(ArrayElement *elt)
+bool CkVerboseListener::ckElementCreated(ArrayElement *elt)
 {
   VL_PRINT<<"LIFE  Created element "<<idx2str(elt)<<endl;
-  return CmiTrue;
+  return true;
 }
 void CkVerboseListener::ckElementDied(ArrayElement *elt)
 {
@@ -220,10 +220,10 @@ void CkVerboseListener::ckElementLeaving(ArrayElement *elt)
 {
   VL_PRINT<<"MIG  Leaving: element "<<idx2str(elt)<<endl;
 }
-CmiBool CkVerboseListener::ckElementArriving(ArrayElement *elt)
+bool CkVerboseListener::ckElementArriving(ArrayElement *elt)
 {
   VL_PRINT<<"MIG  Arriving: element "<<idx2str(elt)<<endl;
-  return CmiTrue;
+  return true;
 }
 
 
@@ -234,7 +234,7 @@ public:
   CkArrayID thisArrayID;
   CkArrayIndex numInitial;
   int listenerData[CK_ARRAYLISTENER_MAXLEN];
-  CmiBool fromMigration;
+  bool fromMigration;
 };
 
 CkpvStaticDeclare(ArrayElement_initInfo,initInfo);
@@ -486,7 +486,7 @@ void ArrayElement::recvBroadcast(CkMessage *m){
        CkArrayMessage *bcast = (CkArrayMessage *)m;
     envelope *env = UsrToEnv(m);
        int epIdx= env->piggyBcastIdx;
-    ckInvokeEntry(epIdx,bcast,CmiTrue);
+    ckInvokeEntry(epIdx,bcast,true);
 #endif
 }
 
@@ -753,7 +753,7 @@ CkArray::CkArray(CkArrayOptions &opts,
     // Register with our location manager
     elements((ArrayElementList *)locMgr->addManager(thisgroup,this)),
     stableLocations(opts.staticInsertion && !opts.anytimeMigration),
-    numInitial(opts.getNumInitial()), isInserting(CmiTrue)
+    numInitial(opts.getNumInitial()), isInserting(true)
 {
   if (!stableLocations)
       CcdCallOnConditionKeep(CcdPERIODIC_1minute,
@@ -761,7 +761,7 @@ CkArray::CkArray(CkArrayOptions &opts,
   
   //set the field in one my parent class (CkReductionMgr)
   if(opts.disableNotifyChildInRed)
-         disableNotifyChildrenStart = CmiTrue; 
+         disableNotifyChildrenStart = true; 
   
   //Find, register, and initialize the arrayListeners
   listenerDataOffset=0;
@@ -832,7 +832,7 @@ CkArray::CkArray(CkMigrateMessage *m)
        :CkReductionMgr(m), thisProxy(thisgroup)
 {
   locMgr=NULL;
-  isInserting=CmiTrue;
+  isInserting=true;
 }
 
 #if CMK_ERROR_CHECKING
@@ -892,7 +892,7 @@ void CkArray::prepareCtorMsg(CkMessage *m,int &onPe,const CkArrayIndex &idx)
 CkMigratable *CkArray::allocateMigrated(int elChareType,const CkArrayIndex &idx,
                        CkElementCreation_t type)
 {
-       ArrayElement *ret=allocate(elChareType,idx,NULL,CmiTrue);
+       ArrayElement *ret=allocate(elChareType,idx,NULL,true);
        if (type==CkElementCreation_resume) 
        { // HACK: Re-stamp elements on checkpoint resume--
          //  this restores, e.g., reduction manager's gcount
@@ -903,7 +903,7 @@ CkMigratable *CkArray::allocateMigrated(int elChareType,const CkArrayIndex &idx,
 }
 
 ArrayElement *CkArray::allocate(int elChareType,const CkArrayIndex &idx,
-                    CkMessage *msg,CmiBool fromMigration) 
+                    CkMessage *msg,bool fromMigration) 
 {
        //Stash the element's initialization information in the global "initInfo"
        ArrayElement_initInfo &init=CkpvAccess(initInfo);
@@ -925,7 +925,7 @@ ArrayElement *CkArray::allocate(int elChareType,const CkArrayIndex &idx,
 }
 
 /// This method is called by ck.C or the user to add an element.
-CmiBool CkArray::insertElement(CkMessage *me)
+bool CkArray::insertElement(CkMessage *me)
 {
   CK_MAGICNUMBER_CHECK
   CkArrayMessage *m=(CkArrayMessage *)me;
@@ -934,18 +934,18 @@ CmiBool CkArray::insertElement(CkMessage *me)
   if (locMgr->isRemote(idx,&onPe)) 
   { /* element's sibling lives somewhere else, so insert there */
        CkArrayManagerInsert(onPe,me,thisgroup);
-       return CmiFalse;
+       return false;
   }
   int ctorIdx=m->array_ep();
   int chareType=_entryTable[ctorIdx]->chareIdx;
-  ArrayElement *elt=allocate(chareType,idx,me,CmiFalse);
+  ArrayElement *elt=allocate(chareType,idx,me,false);
 #ifndef CMK_CHARE_USE_PTR
   ((Chare *)elt)->chareIdx = -1;
 #endif
-  if (!locMgr->addElement(thisgroup,idx,elt,ctorIdx,(void *)m)) return CmiFalse;
+  if (!locMgr->addElement(thisgroup,idx,elt,ctorIdx,(void *)m)) return false;
   CK_ARRAYLISTENER_LOOP(listeners,
-      if (!l->ckElementCreated(elt)) return CmiFalse;);
-  return CmiTrue;
+      if (!l->ckElementCreated(elt)) return false;);
+  return true;
 }
 
 void CProxy_ArrayBase::doneInserting(void)
@@ -976,7 +976,7 @@ void CkArray::remoteDoneInserting(void)
 {
   CK_MAGICNUMBER_CHECK
   if (isInserting) {
-    isInserting=CmiFalse;
+    isInserting=false;
     DEBC((AA"Done inserting objects\n"AB));
     for (int l=0;l<listeners.size();l++) listeners[l]->ckEndInserting();
     locMgr->doneInserting();
@@ -988,14 +988,14 @@ void CkArray::remoteBeginInserting(void)
   CK_MAGICNUMBER_CHECK;
 
   if (!isInserting) {
-    isInserting = CmiTrue;
+    isInserting = true;
     DEBC((AA"Begin inserting objects\n"AB));
     for (int l=0;l<listeners.size();l++) listeners[l]->ckBeginInserting();
     locMgr->startInserting();
   }
 }
 
-CmiBool CkArray::demandCreateElement(const CkArrayIndex &idx,
+bool CkArray::demandCreateElement(const CkArrayIndex &idx,
        int onPe,int ctor,CkDeliver_t type)
 {
        CkArrayMessage *m=(CkArrayMessage *)CkAllocSysMsg();
@@ -1010,7 +1010,7 @@ CmiBool CkArray::demandCreateElement(const CkArrayIndex &idx,
                DEBC((AA"Demand-creating %s\n"AB,idx2str(idx)));
                return insertElement(m);
        }
-       return CmiTrue;
+       return true;
 }
 
 void CkArray::insertInitial(const CkArrayIndex &idx,void *ctorMsg, int local)
@@ -1216,19 +1216,19 @@ void CkArrayBroadcaster::incoming(CkArrayMessage *msg)
 }
 
 /// Deliver a copy of the given broadcast to the given local element
-CmiBool CkArrayBroadcaster::deliver(CkArrayMessage *bcast, ArrayElement *el,
-                                   CmiBool doFree)
+bool CkArrayBroadcaster::deliver(CkArrayMessage *bcast, ArrayElement *el,
+                                   bool doFree)
 {
   int &elBcastNo=getData(el);
   // if this array element already received this message, skip it
-  if (elBcastNo >= bcastNo) return CmiFalse;
+  if (elBcastNo >= bcastNo) return false;
   elBcastNo++;
   DEBB((AA"Delivering broadcast %d to element %s\n"AB,elBcastNo,idx2str(el)));
   int epIdx=bcast->array_ep_bcast();
 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))     
   DEBUG(printf("[%d] elBcastNo %d bcastNo %d \n",CmiMyPe(),bcastNo));
-  return CmiTrue;
+  return true;
 #else
   if (!broadcastViaScheduler)
     return el->ckInvokeEntry(epIdx, bcast, doFree);
@@ -1248,9 +1248,9 @@ CmiBool CkArrayBroadcaster::deliver(CkArrayMessage *bcast, ArrayElement *el,
 }
 
 /// Deliver all needed broadcasts to the given local element
-CmiBool CkArrayBroadcaster::bringUpToDate(ArrayElement *el)
+bool CkArrayBroadcaster::bringUpToDate(ArrayElement *el)
 {
-  if (stableLocations) return CmiTrue;
+  if (stableLocations) return true;
   int &elBcastNo=getData(el);
   if (elBcastNo<bcastNo)
   {//This element needs some broadcasts-- it must have
@@ -1269,12 +1269,12 @@ CmiBool CkArrayBroadcaster::bringUpToDate(ArrayElement *el)
                if(msg == NULL)
                continue;
       oldBcasts.enq(msg);
-      if (!deliver(msg, el, CmiFalse))
-       return CmiFalse; //Element migrated away
+      if (!deliver(msg, el, false))
+       return false; //Element migrated away
     }
   }
   //Otherwise, the element survived
-  return CmiTrue;
+  return true;
 }
 
 
@@ -1456,8 +1456,8 @@ void CkArray::recvBroadcast(CkMessage *m)
                 logs.push_back(curlog);
                startVTimer();
 #endif
-               CmiBool doFree = CmiFalse;
-               if (stableLocations && ++count == len) doFree = CmiTrue;
+               bool doFree = false;
+               if (stableLocations && ++count == len) doFree = true;
                broadcaster->deliver(msg, el, doFree);
        }
 #endif
index 79a6fe42d9c92125a914459971b5e3f35366d723..18b9014aa1156b6ec24cf9a8a2b5ad8da7a596d7 100644 (file)
@@ -3,7 +3,7 @@ module CkArray {
   extern module CkLocation;
   extern module CkArrayReductionMgr;
 
-  readonly CmiBool _isAnytimeMigration;
+  readonly bool _isAnytimeMigration;
   
   group [migratable] CkArray : CkReductionMgr {
        entry CkArray(CkArrayOptions opts, CkMarshalledMessage ctorMsg, CkNodeGroupID nodereductionProxy);
index 0ee32edaba063012366e2ea90900275eb71a688e..1ff87a53b422c2c2fa10ede651441f7c4ef91283 100644 (file)
@@ -170,8 +170,8 @@ class CkArrayListener : public PUP::able {
   virtual void ckElementCreating(ArrayElement *elt) {}
   ///Element was just created on this processor
   /// Return false if the element migrated away or deleted itself.
-  virtual CmiBool ckElementCreated(ArrayElement *elt)
-    { return CmiTrue; }
+  virtual bool ckElementCreated(ArrayElement *elt)
+    { return true; }
 
   ///Element is about to be destroyed
   virtual void ckElementDied(ArrayElement *elt) {}
@@ -182,8 +182,8 @@ class CkArrayListener : public PUP::able {
 
   ///Element just arrived on this processor (so just called pup)
   /// Return false if the element migrated away or deleted itself.
-  virtual CmiBool ckElementArriving(ArrayElement *elt)
-    { return CmiTrue; }
+  virtual bool ckElementArriving(ArrayElement *elt)
+    { return true; }
 
   /// used by checkpointing to reset the states
   virtual void flushState()  {}
@@ -204,11 +204,11 @@ class CkVerboseListener : public CkArrayListener {
 
   virtual void ckElementStamp(int *eltInfo);
   virtual void ckElementCreating(ArrayElement *elt);
-  virtual CmiBool ckElementCreated(ArrayElement *elt);
+  virtual bool ckElementCreated(ArrayElement *elt);
   virtual void ckElementDied(ArrayElement *elt);
 
   virtual void ckElementLeaving(ArrayElement *elt);
-  virtual CmiBool ckElementArriving(ArrayElement *elt);
+  virtual bool ckElementArriving(ArrayElement *elt);
 };
 
 /**
@@ -694,10 +694,10 @@ public:
   void remoteBeginInserting(void);
 
   /// Create manually:
-  virtual CmiBool insertElement(CkMessage *);
+  virtual bool insertElement(CkMessage *);
 
 /// Demand-creation:
-  CmiBool demandCreateElement(const CkArrayIndex &idx,
+  bool demandCreateElement(const CkArrayIndex &idx,
        int onPe,int ctor,CkDeliver_t type);
 
 /// Broadcast communication:
@@ -715,15 +715,15 @@ public:
   //ComlibArrayListener * calistener;
   //ComlibArrayListener * getComlibArrayListener() {return calistener;}
 
-  virtual CmiBool isArrMgr(void) {return CmiTrue;}
+  virtual bool isArrMgr(void) {return true;}
 
 private:
   CkArrayIndex numInitial;/// Number of initial array elements
-  CmiBool isInserting;/// Are we currently inserting elements?
+  bool isInserting;/// Are we currently inserting elements?
 
 /// Allocate space for a new array element
   ArrayElement *allocate(int elChareType,const CkArrayIndex &idx,
-       CkMessage *msg,CmiBool fromMigration);
+       CkMessage *msg,bool fromMigration);
 
 //Spring cleaning
   void springCleaning(void);
index 759954ad7ffbeebbc3b7e640732f7e6d71c5f3bb..f243e88d301741fc26d6fe565a726989c796a6f7 100644 (file)
@@ -93,12 +93,12 @@ class CkArrayIndex: public CkArrayIndexBase
         void print() const { CmiPrintf("%d: %d %d %d\n", nInts, index[0], index[1], index[2]); }
 
         /// Equality comparison
-        CmiBool operator==(const CkArrayIndex& idx) const
+        bool operator==(const CkArrayIndex& idx) const
         {
-            if (nInts != idx.nInts) return CmiFalse;
+            if (nInts != idx.nInts) return false;
             for (int i=0; i<nInts; i++)
-                if (index[i] != idx.index[i]) return CmiFalse;
-            return CmiTrue;
+                if (index[i] != idx.index[i]) return false;
+            return true;
         }
 
         /// These routines allow CkArrayIndex to be used in a CkHashtableT
index 6b35e0d39736e7ed53fcbf9ee6fa8a4c3a7f738d..78327e16cadf577a16907724a44d0ff5809a6c07 100644 (file)
@@ -84,7 +84,7 @@ void *CkCallback::impl_thread_delay(void) const
 /*These can't be defined in the .h file like the other constructors
  * because we need CkCallback before CProxyElement* are defined.
  */
-CkCallback::CkCallback(Chare *p, int ep, CmiBool doInline) {
+CkCallback::CkCallback(Chare *p, int ep, bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -92,14 +92,14 @@ CkCallback::CkCallback(Chare *p, int ep, CmiBool doInline) {
        d.chare.ep=ep; 
        d.chare.id=p->ckGetChareID();
 }
-CkCallback::CkCallback(Group *p, int ep, CmiBool doInline) {
+CkCallback::CkCallback(Group *p, int ep, bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
       type=doInline?isendGroup:sendGroup;
        d.group.ep=ep; d.group.id=p->ckGetGroupID(); d.group.onPE=CkMyPe();
 }
-CkCallback::CkCallback(NodeGroup *p, int ep, CmiBool doInline) {
+CkCallback::CkCallback(NodeGroup *p, int ep, bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -115,7 +115,7 @@ CkCallback::CkCallback(int ep,const CProxy_NodeGroup &ngp) {
        d.group.ep=ep; d.group.id=ngp.ckGetGroupID();
 }
 
-CkCallback::CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,CmiBool doInline) {
+CkCallback::CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -123,7 +123,7 @@ CkCallback::CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,CmiBool doInl
        d.group.ep=ep; d.group.id=ngp.ckGetGroupID(); d.group.onPE=onPE;
 }
 
-CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,CmiBool doInline) {
+CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -132,7 +132,7 @@ CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,CmiBool doInline
        d.group.id=grpElt.ckGetGroupID(); 
        d.group.onPE=grpElt.ckGetGroupPe();
 }
-CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,CmiBool doInline) {
+CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -142,7 +142,7 @@ CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,CmiBool doIn
        d.array.idx = arrElt.ckGetIndex();
 }
 
-CkCallback::CkCallback(int ep,CProxySection_ArrayBase &sectElt,CmiBool doInline) {
+CkCallback::CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
@@ -171,7 +171,7 @@ CkCallback::CkCallback(int ep, CkSectionID &id) {
       d.section.npes = id.npes;
 }
 
-CkCallback::CkCallback(ArrayElement *p, int ep,CmiBool doInline) {
+CkCallback::CkCallback(ArrayElement *p, int ep,bool doInline) {
 #ifndef CMK_OPTIMIZE
       bzero(this, sizeof(CkCallback));
 #endif
index 0d509835e6bfeddb8243e5cdd4f27bdd6be1a7b0..efa11ae240d5a0c5a89469154db68b4d05795a03 100644 (file)
@@ -140,7 +140,7 @@ public:
        }
 
     // Call a chare entry method
-       CkCallback(int ep,const CkChareID &id,CmiBool doInline=CmiFalse) {
+       CkCallback(int ep,const CkChareID &id,bool doInline=false) {
 #if CMK_REPLAYSYSTEM
       bzero(this, sizeof(CkCallback));
 #endif
@@ -161,10 +161,10 @@ public:
        }
 
     // Send to nodegroup element
-       CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,CmiBool doInline=CmiFalse);
+       CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool doInline=false);
 
     // Send to group/nodegroup element
-       CkCallback(int ep,int onPE,const CkGroupID &id,CmiBool doInline=CmiFalse, int isNodeGroup=0) {
+       CkCallback(int ep,int onPE,const CkGroupID &id,bool doInline=false, int isNodeGroup=0) {
 #if CMK_REPLAYSYSTEM
       bzero(this, sizeof(CkCallback));
 #endif
@@ -173,7 +173,7 @@ public:
        }
 
     // Send to specified group element
-       CkCallback(int ep,const CProxyElement_Group &grpElt,CmiBool doInline=CmiFalse);
+       CkCallback(int ep,const CProxyElement_Group &grpElt,bool doInline=false);
        
     // Bcast to array
        CkCallback(int ep,const CkArrayID &id) {
@@ -185,7 +185,7 @@ public:
        }
 
     // Send to array element
-       CkCallback(int ep,const CkArrayIndex &idx,const CkArrayID &id,CmiBool doInline=CmiFalse) {
+       CkCallback(int ep,const CkArrayIndex &idx,const CkArrayID &id,bool doInline=false) {
 #if CMK_REPLAYSYSTEM
       bzero(this, sizeof(CkCallback));
 #endif
@@ -194,23 +194,23 @@ public:
        }
 
     // Bcast to array
-       CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,CmiBool doInline=CmiFalse);
+       CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool doInline=false);
        
        //Bcast to section
-       CkCallback(int ep,CProxySection_ArrayBase &sectElt,CmiBool doInline=CmiFalse);
+       CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool doInline=false);
        CkCallback(int ep, CkSectionID &sid);
        
        // Send to chare
-       CkCallback(Chare *p, int ep, CmiBool doInline=CmiFalse);
+       CkCallback(Chare *p, int ep, bool doInline=false);
 
     // Send to group element on current PE
-       CkCallback(Group *p, int ep, CmiBool doInline=CmiFalse);
+       CkCallback(Group *p, int ep, bool doInline=false);
 
     // Send to nodegroup element on current node
-       CkCallback(NodeGroup *p, int ep, CmiBool doInline=CmiFalse);
+       CkCallback(NodeGroup *p, int ep, bool doInline=false);
 
     // Send to specified array element 
-       CkCallback(ArrayElement *p, int ep,CmiBool doInline=CmiFalse);
+       CkCallback(ArrayElement *p, int ep,bool doInline=false);
 
        CkCallback(const CcsDelayedReply &reply) {
 #if CMK_REPLAYSYSTEM
index b37371434ba1801211d73c186cff11a063bd0f85..db789231bccb6ffcfbfabcf974ee15f1f61900ca 100644 (file)
@@ -1405,11 +1405,11 @@ void startMlogCheckpoint(void *_dummy, double curWallTime){
        }
        CkPupROData(psizer);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupGroupData(psizer,CmiTrue);
+       CkPupGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupNodeGroupData(psizer,CmiTrue);
+       CkPupNodeGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       pupArrayElementsSkip(psizer,CmiTrue,NULL);
+       pupArrayElementsSkip(psizer,true,NULL);
        DEBUG_MEM(CmiMemoryCheck());
 
        int dataSize = psizer.size();
@@ -1427,9 +1427,9 @@ void startMlogCheckpoint(void *_dummy, double curWallTime){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiTrue);
-       CkPupNodeGroupData(pBuf,CmiTrue);
-       pupArrayElementsSkip(pBuf,CmiTrue,NULL);
+       CkPupGroupData(pBuf,true);
+       CkPupNodeGroupData(pBuf,true);
+       pupArrayElementsSkip(pBuf,true,NULL);
 
        unAckedCheckpoint=1;
        CmiSetHandler(msg,_storeCheckpointHandlerIdx);
@@ -1494,7 +1494,7 @@ public:
 /**
  * Pups all the array elements in this processor.
  */
-void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSkip,int listsize){
+void pupArrayElementsSkip(PUP::er &p, bool create, MigrationRecord *listToSkip,int listsize){
        int numElements,i;
        int numGroups = CkpvAccess(_groupIDTable)->size();      
        if(!p.isUnpacking()){
@@ -1975,9 +1975,9 @@ void _recvRestartCheckpointHandler(char *_restartData){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiFalse);
-       CkPupNodeGroupData(pBuf,CmiFalse);
-       pupArrayElementsSkip(pBuf,CmiFalse,NULL);
+       CkPupGroupData(pBuf,false);
+       CkPupNodeGroupData(pBuf,false);
+       pupArrayElementsSkip(pBuf,false,NULL);
        CkAssert(pBuf.size() == restartData->checkPointSize);
        printf("[%d] Restart Objects created from CheckPointData at %.6lf \n",CkMyPe(),CmiWallTimer());
 
@@ -2257,9 +2257,9 @@ void _recvCheckpointHandler(char *_restartData){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiTrue);
-       CkPupNodeGroupData(pBuf,CmiTrue);
-       pupArrayElementsSkip(pBuf,CmiTrue,NULL);
+       CkPupGroupData(pBuf,true);
+       CkPupNodeGroupData(pBuf,true);
+       pupArrayElementsSkip(pBuf,true,NULL);
        CkAssert(pBuf.size() == restartData->checkPointSize);
        printf("[%d] Restart Objects created from CheckPointData at %.6lf \n",CkMyPe(),CmiWallTimer());
 
@@ -3095,9 +3095,9 @@ public:
                pmem.becomeDeleting();
                pupLocation(loc,pmem);
                        
-               locMgr->setDuringMigration(CmiTrue);
+               locMgr->setDuringMigration(true);
                delete rec;
-               locMgr->setDuringMigration(CmiFalse);
+               locMgr->setDuringMigration(false);
                locMgr->inform(idx,*targetPE);
 
                CmiSetHandler(msg,_distributedLocationHandlerIdx);
@@ -3139,7 +3139,7 @@ void _sendBackLocationHandler(char *receivedMsg){
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
        donotCountMigration=1;
-       mgr->resume(idx,pmem,CmiTrue);
+       mgr->resume(idx,pmem,true);
        donotCountMigration=0;
        informLocationHome(gID,idx,mgr->homePe(idx),CkMyPe());
        printf("Array element inserted at processor %d after parallel recovery\n",CkMyPe());
@@ -3176,7 +3176,7 @@ void _distributedLocationHandler(char *receivedMsg){
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
        donotCountMigration=1;
-       mgr->resume(idx,pmem,CmiTrue);
+       mgr->resume(idx,pmem,true);
        donotCountMigration=0;
        informLocationHome(gID,idx,mgr->homePe(idx),CkMyPe());
        printf("Array element inserted at processor %d after distribution at restart ",CkMyPe());
@@ -3391,9 +3391,9 @@ void sendBackImmigrantRecObjs(){
                pmem.becomeDeleting();
                pupLocation(loc,locMgr,pmem);
                
-               locMgr->setDuringMigration(CmiTrue);
+               locMgr->setDuringMigration(true);
                delete rec;
-               locMgr->setDuringMigration(CmiFalse);
+               locMgr->setDuringMigration(false);
                locMgr->inform(idx,targetPE);
 
                // sending the object
index ab358a344c8fc50a8a5aeba2ffdfb1e5e467dc5e..45dd998b10d61a61a0eaeb14588aa771ea939d00 100644 (file)
@@ -544,7 +544,7 @@ CpvExtern(StoredCheckpoint *,_storedCheckpointData);
 //methods for checkpointing
 void checkpointAlarm(void *_dummy,double curWallTime);
 void startMlogCheckpoint(void *_dummy,double curWallTime);
-void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSkip,int listSize=0);
+void pupArrayElementsSkip(PUP::er &p, bool create, MigrationRecord *listToSkip,int listSize=0);
 
 //handler functions for checkpoint
 void _checkpointRequestHandler(CheckpointRequest *request);
index 1c8086f8c76b694f769b4011d9633c5d956c50e9..b0fa20c9b502738e196cec3d26ea0e9735ffd434 100644 (file)
@@ -174,7 +174,7 @@ void CkCheckpointMgr::Checkpoint(const char *dirname, CkCallback& cb){
        FILE* fGroups = openCheckpointFile(dirname, "Groups", "wb", CkMyPe());
        PUP::toDisk pGroups(fGroups);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-    CkPupGroupData(pGroups,CmiTrue);
+    CkPupGroupData(pGroups,true);
 #else
     CkPupGroupData(pGroups);
 #endif
@@ -186,7 +186,7 @@ void CkCheckpointMgr::Checkpoint(const char *dirname, CkCallback& cb){
          FILE* fNodeGroups = openCheckpointFile(dirname, "NodeGroups", "wb", CkMyNode());
          PUP::toDisk pNodeGroups(fNodeGroups);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-      CkPupNodeGroupData(pNodeGroups,CmiTrue);
+      CkPupNodeGroupData(pNodeGroups,true);
 #else
       CkPupNodeGroupData(pNodeGroups);
 #endif
@@ -318,7 +318,7 @@ void CkPupChareData(PUP::er &p)
 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
 // handle GroupTable and data
-void CkPupGroupData(PUP::er &p, CmiBool create)
+void CkPupGroupData(PUP::er &p, bool create)
 {
        int numGroups, i;
 
@@ -380,7 +380,7 @@ void CkPupGroupData(PUP::er &p, CmiBool create)
 }
 
 // handle NodeGroupTable and data
-void CkPupNodeGroupData(PUP::er &p, CmiBool create)
+void CkPupNodeGroupData(PUP::er &p, bool create)
 {
        int numNodeGroups, i;
        if (!p.isUnpacking()) {
@@ -570,7 +570,7 @@ void CkPupArrayElementsData(PUP::er &p, int notifyListeners)
                 p|idx;
                CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
                if (notifyListeners){
-                 mgr->resume(idx,p,CmiTrue);
+                 mgr->resume(idx,p,true);
                }
                 else{
                  mgr->restore(idx,p);
@@ -613,7 +613,7 @@ void CkPupProcessorData(PUP::er &p)
 
     // save groups 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-    CkPupGroupData(p,CmiTrue);
+    CkPupGroupData(p,true);
 #else
     CkPupGroupData(p);
 #endif
@@ -621,7 +621,7 @@ void CkPupProcessorData(PUP::er &p)
     // save nodegroups
     if(CkMyRank()==0) {
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-        CkPupNodeGroupData(p,CmiTrue); 
+        CkPupNodeGroupData(p,true);    
 #else
         CkPupNodeGroupData(p);
 #endif
@@ -749,7 +749,7 @@ void CkRestartMain(const char* dirname, CkArgMsg *args){
                                            (CkNumPes() == _numPes) ? CkMyPe() : 0);
        PUP::fromDisk pGroups(fGroups);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-    CkPupGroupData(pGroups,CmiTrue);
+    CkPupGroupData(pGroups,true);
 #else
     CkPupGroupData(pGroups);
 #endif
@@ -762,7 +762,7 @@ void CkRestartMain(const char* dirname, CkArgMsg *args){
                                                        (CkNumPes() == _numPes) ? CkMyNode() : 0);
                 PUP::fromDisk pNodeGroups(fNodeGroups);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-        CkPupNodeGroupData(pNodeGroups,CmiTrue);
+        CkPupNodeGroupData(pNodeGroups,true);
 #else
         CkPupNodeGroupData(pNodeGroups);
 #endif
index 3c4f7b14a37b13e17fcadd56b45ef2087a7e006e..340c4ff29df38fedd6ad4d244ada325bc5cd326a 100644 (file)
@@ -45,8 +45,8 @@ void CkPupROData(PUP::er &p);
 void CkPupMainChareData(PUP::er &p, CkArgMsg *args);
 void CkPupChareData(PUP::er &p);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-void CkPupGroupData(PUP::er &p,CmiBool create=CmiTrue);
-void CkPupNodeGroupData(PUP::er &p,CmiBool create=CmiTrue);
+void CkPupGroupData(PUP::er &p,bool create=true);
+void CkPupNodeGroupData(PUP::er &p,bool create=true);
 #else
 void CkPupGroupData(PUP::er &p);
 void CkPupNodeGroupData(PUP::er &p);
index 9c67231ce1e41458a6cb2b6a9dce7070725272bf..6f5f478bac8a521e15f296f331af42f323d408fd 100644 (file)
@@ -118,7 +118,7 @@ void CkEmmigrateElement(void *arg){
        int targetPE=getNextPE(idx);
        //set this flag so that load balancer is not informed when
        //this element migrates
-       rec->AsyncMigrate(CmiTrue);
+       rec->AsyncMigrate(true);
        mgr->emigrate(rec,targetPE);
        CkEvacuatedElement();
        
@@ -237,7 +237,7 @@ void CkElementEvacuate::addLocation(CkLocation &loc){
        if(rec->isAsyncEvacuate()){
                numEvacuated++;
                printf("[%d]<%.6lf> START to emigrate array element \n",CkMyPe(),CmiWallTimer());
-               rec->AsyncMigrate(CmiTrue);
+               rec->AsyncMigrate(true);
                locMgr->emigrate(rec,targetPE);
                printf("[%d]<%.6lf> emigrated array element \n",CkMyPe(),CmiWallTimer());
        }else{
@@ -252,7 +252,7 @@ void CkElementEvacuate::addLocation(CkLocation &loc){
                        if(list[i]->isAsyncEvacuate()){
                                DEBUGC(printf("[%d] possible TCharm element decides to migrate \n",CkMyPe()));
 //                             list[i]->ckMigrate(targetPE);
-                               rec->AsyncMigrate(CmiTrue);
+                               rec->AsyncMigrate(true);
                                locMgr->emigrate(rec,targetPE);
                                numEvacuated++;
                        }
index 05d7bd8917f6f69a87fa6da5c97afe4221a09a45..8c36766321fe815857263aaea5189dc9a2f8a1d3 100644 (file)
@@ -996,7 +996,7 @@ void CkArrayPrefetch_readFromSwap(FILE *swapfile,void *objptr) {
   //Call the element's migration constructor in-place
   CkpvAccess(CkSaveRestorePrefetch)=1;
   int ctorIdx=_chareTable[elt->thisChareType]->migCtor;
-  elt->myRec->invokeEntry(elt,(CkMigrateMessage *)0,ctorIdx,CmiTrue);
+  elt->myRec->invokeEntry(elt,(CkMigrateMessage *)0,ctorIdx,true);
   CkpvAccess(CkSaveRestorePrefetch)=0;
   
   //Restore the element's data from disk:
@@ -1024,7 +1024,7 @@ class CkMigratable_initInfo {
 public:
        CkLocRec_local *locRec;
        int chareType;
-       CmiBool forPrefetch; /* If true, this creation is only a prefetch restore-from-disk.*/
+       bool forPrefetch; /* If true, this creation is only a prefetch restore-from-disk.*/
 };
 
 CkpvStaticDeclare(CkMigratable_initInfo,mig_initInfo);
@@ -1040,7 +1040,7 @@ void _CkMigratable_initInfoInit(void) {
 void CkMigratable::commonInit(void) {
        CkMigratable_initInfo &i=CkpvAccess(mig_initInfo);
 #if CMK_OUT_OF_CORE
-       isInCore=CmiTrue;
+       isInCore=true;
        if (CkpvAccess(CkSaveRestorePrefetch))
                return; /* Just restoring from disk--don't touch object */
        prefetchObjID=-1; //Unregistered
@@ -1048,9 +1048,9 @@ void CkMigratable::commonInit(void) {
        myRec=i.locRec;
        thisIndexMax=myRec->getIndex();
        thisChareType=i.chareType;
-       usesAtSync=CmiFalse;
-       usesAutoMeasure=CmiTrue;
-       barrierRegistered=CmiFalse;
+       usesAtSync=false;
+       usesAutoMeasure=true;
+       barrierRegistered=false;
 
   local_state = OFF;
   prev_load = 0.0;
@@ -1065,7 +1065,7 @@ void CkMigratable::commonInit(void) {
        /*
        FAULT_EVAC
        */
-       AsyncEvacuate(CmiTrue);
+       AsyncEvacuate(true);
 }
 
 CkMigratable::CkMigratable(void) {
@@ -1091,7 +1091,7 @@ void CkMigratable::pup(PUP::er &p) {
        p|readyMigrate;
        if (p.isUnpacking()) myRec->ReadyMigrate(readyMigrate);
 #endif
-       if(p.isUnpacking()) barrierRegistered=CmiFalse;
+       if(p.isUnpacking()) barrierRegistered=false;
        /*
                FAULT_EVAC
        */
@@ -1113,7 +1113,7 @@ void CkMigratable::ckJustRestored(void) { }
 CkMigratable::~CkMigratable() {
        DEBC((AA"In CkMigratable::~CkMigratable %s\n"AB,idx2str(thisIndexMax)));
 #if CMK_OUT_OF_CORE
-       isInCore=CmiFalse;
+       isInCore=false;
        if (CkpvAccess(CkSaveRestorePrefetch)) 
                return; /* Just saving to disk--don't deregister anything. */
        /* We're really leaving or dying-- unregister from the ooc system*/
@@ -1216,22 +1216,22 @@ void CkMigratable::ckFinishConstruction(void)
         else
          ldBarrierRecvHandle = myRec->getLBDB()->AddLocalBarrierReceiver(
                (LDBarrierFn)staticResumeFromSync,(void*)(this));
-       barrierRegistered=CmiTrue;
+       barrierRegistered=true;
 }
 
 void CkMigratable::AtSync(int waitForMigration)
 {
        if (!usesAtSync)
-               CkAbort("You must set usesAtSync=CmiTrue in your array element constructor to use AtSync!\n");
+               CkAbort("You must set usesAtSync=true in your array element constructor to use AtSync!\n");
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
         mlogData->toResumeOrNot=1;
 #endif
        myRec->AsyncMigrate(!waitForMigration);
-       if (waitForMigration) ReadyMigrate(CmiTrue);
+       if (waitForMigration) ReadyMigrate(true);
        ckFinishConstruction();
   DEBL((AA"Element %s going to sync\n"AB,idx2str(thisIndexMax)));
   // model-based load balancing, ask user to provide cpu load
-  if (usesAutoMeasure == CmiFalse) UserSetLBLoad();
+  if (usesAutoMeasure == false) UserSetLBLoad();
 
   if (!_lb_args.metaLbOn()) {
     myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
@@ -1280,7 +1280,7 @@ void CkMigratable::AtSync(int waitForMigration)
   }
 }
 
-void CkMigratable::ReadyMigrate(CmiBool ready)
+void CkMigratable::ReadyMigrate(bool ready)
 {
        myRec->ReadyMigrate(ready);
 }
@@ -1401,20 +1401,20 @@ Matches up the array index with the local index, an
 interfaces with the load balancer on behalf of the
 represented array elements.
 */
-CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
-  CmiBool ignoreArrival, const CkArrayIndex &idx_,int localIdx_)
+CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,bool fromMigration,
+  bool ignoreArrival, const CkArrayIndex &idx_,int localIdx_)
        :CkLocRec(mgr),idx(idx_),localIdx(localIdx_),
-        running(CmiFalse),deletedMarker(NULL)
+        running(false),deletedMarker(NULL)
 {
 #if CMK_LBDB_ON
        DEBL((AA"Registering element %s with load balancer\n"AB,idx2str(idx)));
        //BIGSIM_OOC DEBUGGING
        //CkPrintf("LocMgr on %d: Registering element %s with load balancer\n", CkMyPe(), idx2str(idx));
        nextPe = -1;
-       asyncMigrate = CmiFalse;
-       readyMigrate = CmiTrue;
-        enable_measure = CmiTrue;
-       bounced  = CmiFalse;
+       asyncMigrate = false;
+       readyMigrate = true;
+        enable_measure = true;
+       bounced  = false;
        the_lbdb=mgr->getLBDB();
        the_metalb=mgr->getMetaBalancer();
        LDObjid ldid = idx2LDObjid(idx);
@@ -1426,20 +1426,20 @@ CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
        if (fromMigration) {
                DEBL((AA"Element %s migrated in\n"AB,idx2str(idx)));
                if (!ignoreArrival)  {
-                       the_lbdb->Migrated(ldHandle, CmiTrue);
+                       the_lbdb->Migrated(ldHandle, true);
                  // load balancer should ignore this objects movement
-               //  AsyncMigrate(CmiTrue);
+               //  AsyncMigrate(true);
                }
        }
 #endif
        /*
                FAULT_EVAC
        */
-       asyncEvacuate = CmiTrue;
+       asyncEvacuate = true;
 }
 CkLocRec_local::~CkLocRec_local()
 {
-       if (deletedMarker!=NULL) *deletedMarker=CmiTrue;
+       if (deletedMarker!=NULL) *deletedMarker=true;
        myLocMgr->reclaim(idx,localIdx);
 #if CMK_LBDB_ON
        stopTiming();
@@ -1464,14 +1464,14 @@ void CkLocRec_local::metaLBCallLB() {
 }
 
 void CkLocRec_local::startTiming(int ignore_running) {
-       if (!ignore_running) running=CmiTrue;
+       if (!ignore_running) running=true;
        DEBL((AA"Start timing for %s at %.3fs {\n"AB,idx2str(idx),CkWallTimer()));
        if (enable_measure) the_lbdb->ObjectStart(ldHandle);
 }
 void CkLocRec_local::stopTiming(int ignore_running) {
        DEBL((AA"} Stop timing for %s at %.3fs\n"AB,idx2str(idx),CkWallTimer()));
        if ((ignore_running || running) && enable_measure) the_lbdb->ObjectStop(ldHandle);
-       if (!ignore_running) running=CmiFalse;
+       if (!ignore_running) running=false;
 }
 void CkLocRec_local::setObjTime(double cputime) {
        the_lbdb->EstObjLoad(ldHandle, cputime);
@@ -1511,7 +1511,7 @@ void CkLocRec_local::addedElement(void)
                CkArrayManagerDeliver(CkMyPe(),halfCreated.deq());
 }
 
-CmiBool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
+bool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
 { 
        int len=halfCreated.length();
        if (len!=0) {
@@ -1523,7 +1523,7 @@ CmiBool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
                         len,idx2str(idx));
        }
        //A local element never expires
-       return CmiFalse;
+       return false;
 }
 
 /**********Added for cosmology (inline function handling without parameter marshalling)***********/
@@ -1540,7 +1540,7 @@ LDObjHandle CkMigratable::timingBeforeCall(int* objstopped){
 #endif
 
   //DEBS((AA"   Invoking entry %d on element %s\n"AB,epIdx,idx2str(idx)));
-       //CmiBool isDeleted=CmiFalse; //Enables us to detect deletion during processing
+       //bool isDeleted=false; //Enables us to detect deletion during processing
        //deletedMarker=&isDeleted;
 /*#ifndef CMK_OPTIMIZE
        if (msg) {  Tracing: 
@@ -1566,9 +1566,9 @@ void CkMigratable::timingAfterCall(LDObjHandle objHandle,int *objstopped){
 //#if CMK_LBDB_ON
 //        if (!isDeleted) checkBufferedMigration();   // check if should migrate
 //#endif
-//     if (isDeleted) return CmiFalse;//We were deleted
+//     if (isDeleted) return false;//We were deleted
 //     deletedMarker=NULL;
-//     return CmiTrue;
+//     return true;
        myRec->stopTiming(1);
 #if CMK_LBDB_ON
        if (*objstopped) {
@@ -1581,12 +1581,12 @@ void CkMigratable::timingAfterCall(LDObjHandle objHandle,int *objstopped){
 /****************************************************************************/
 
 
-CmiBool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,
-       int epIdx,CmiBool doFree) 
+bool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,
+       int epIdx,bool doFree) 
 {
 
        DEBS((AA"   Invoking entry %d on element %s\n"AB,epIdx,idx2str(idx)));
-       CmiBool isDeleted=CmiFalse; //Enables us to detect deletion during processing
+       bool isDeleted=false; //Enables us to detect deletion during processing
        deletedMarker=&isDeleted;
        startTiming();
 
@@ -1616,20 +1616,20 @@ CmiBool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,
 #if CMK_LBDB_ON
         if (!isDeleted) checkBufferedMigration();   // check if should migrate
 #endif
-       if (isDeleted) return CmiFalse;//We were deleted
+       if (isDeleted) return false;//We were deleted
        deletedMarker=NULL;
        stopTiming();
-       return CmiTrue;
+       return true;
 }
 
-CmiBool CkLocRec_local::deliver(CkArrayMessage *msg,CkDeliver_t type,int opts)
+bool CkLocRec_local::deliver(CkArrayMessage *msg,CkDeliver_t type,int opts)
 {
 
        if (type==CkDeliver_queue) { /*Send via the message queue */
                if (opts & CK_MSG_KEEP)
                        msg = (CkArrayMessage *)CkCopyMsg((void **)&msg);
                CkArrayManagerDeliver(CkMyPe(),msg,opts);
-               return CmiTrue;
+               return true;
        }
        else
        {
@@ -1644,13 +1644,13 @@ CmiBool CkLocRec_local::deliver(CkArrayMessage *msg,CkDeliver_t type,int opts)
                        else {
                                DEBS((AA"   BUFFERING message for nonexistent element %s!\n"AB,idx2str(this->idx)));
                                halfCreated.enq(msg);
-                               return CmiTrue;
+                               return true;
                        }
                }
                        
                if (msg->array_hops()>1)
                        myLocMgr->multiHop(msg);
-               CmiBool doFree = (CmiBool)!(opts & CK_MSG_KEEP);
+               bool doFree = (bool)!(opts & CK_MSG_KEEP);
 #if CMK_LBDB_ON
                // if there is a running obj being measured, stop it temporarily
                LDObjHandle objHandle;
@@ -1665,7 +1665,7 @@ CmiBool CkLocRec_local::deliver(CkArrayMessage *msg,CkDeliver_t type,int opts)
                CpvAccess(CkGridObject) = obj;
 #endif
 
-       CmiBool status = invokeEntry(obj,(void *)msg,msg->array_ep(),doFree);
+       bool status = invokeEntry(obj,(void *)msg,msg->array_ep(),doFree);
        
 #if CMK_GRID_QUEUE_AVAILABLE
                CpvAccess(CkGridObject) = NULL;
@@ -1716,13 +1716,13 @@ void CkLocRec_local::recvMigrate(int toPe)
        else nextPe = toPe;
 }
 
-void CkLocRec_local::AsyncMigrate(CmiBool use)  
+void CkLocRec_local::AsyncMigrate(bool use)  
 {
         asyncMigrate = use; 
        the_lbdb->UseAsyncMigrate(ldHandle, use);
 }
 
-CmiBool CkLocRec_local::checkBufferedMigration()
+bool CkLocRec_local::checkBufferedMigration()
 {
        // we don't migrate in user's code when calling ReadyMigrate(true)
        // we postphone the action to here until we exit from the user code.
@@ -1732,9 +1732,9 @@ CmiBool CkLocRec_local::checkBufferedMigration()
            // don't migrate inside the object call
            migrateMe(toPe);
            // don't do anything
-           return CmiTrue;
+           return true;
        }
-       return CmiFalse;
+       return false;
 }
 
 int CkLocRec_local::MigrateToPe()
@@ -1753,7 +1753,7 @@ void CkLocRec_local::setMigratable(int migratable)
 }
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
 void CkLocRec_local::Migrated(){
-    the_lbdb->Migrated(ldHandle, CmiTrue);
+    the_lbdb->Migrated(ldHandle, true);
 }
 #endif
 #endif
@@ -1769,16 +1769,16 @@ public:
   
        virtual RecType type(void) {return dead;}
   
-       virtual CmiBool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
+       virtual bool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
                CkPrintf("Dead array element is %s.\n",idx2str(msg->array_index()));
                CkAbort("Send to dead array element!\n");
-               return CmiFalse;
+               return false;
        }
        virtual void beenReplaced(void) 
                {CkAbort("Can't re-use dead array element!\n");}
   
        //Return if this element is now obsolete (it isn't)
-       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx) {return CmiFalse;}     
+       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx) {return false;}   
 };
 
 /**
@@ -1794,16 +1794,16 @@ protected:
                lastAccess=myLocMgr->getSpringCount();
        }
        //Return if we are "stale"-- we were last accessed a while ago
-       CmiBool isStale(void) {
-               if (myLocMgr->getSpringCount()-lastAccess>3) return CmiTrue;
-               else return CmiFalse;
+       bool isStale(void) {
+               if (myLocMgr->getSpringCount()-lastAccess>3) return true;
+               else return false;
        }
 public:
        CkLocRec_aging(CkLocMgr *Narr):CkLocRec(Narr) {
                lastAccess=myLocMgr->getSpringCount();
        }
        //Return if this element is now obsolete
-       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx)=0;
+       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx)=0;
        //virtual void pup(PUP::er &p) { CkLocRec::pup(p); p(lastAccess); }
 };
 
@@ -1831,7 +1831,7 @@ public:
        virtual RecType type(void) {return remote;}
   
        //Send a message for this element.
-       virtual CmiBool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
+       virtual bool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
                /*FAULT_EVAC*/
                int destPE = onPe;
                if((!CmiNodeAlive(onPe) && onPe != allowMessagesOnly)){
@@ -1849,18 +1849,18 @@ public:
                if (opts & CK_MSG_KEEP)
                        msg = (CkArrayMessage *)CkCopyMsg((void **)&msg);
                CkArrayManagerDeliver(destPE,msg,opts);
-               return CmiTrue;
+               return true;
        }
        //Return if this element is now obsolete
-       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx) {
+       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx) {
                if (myLocMgr->isHome(idx)) 
                        //Home elements never become obsolete
                        // if they did, we couldn't deliver messages to that element.
-                       return CmiFalse;
+                       return false;
                else if (isStale())
-                       return CmiTrue;//We haven't been used in a long time
+                       return true;//We haven't been used in a long time
                else
-                       return CmiFalse;//We're fairly recent
+                       return false;//We're fairly recent
        }
        //virtual void pup(PUP::er &p) { CkLocRec_aging::pup(p); p(onPe); }
 };
@@ -1895,7 +1895,7 @@ public:
        virtual RecType type(void) {return buffering;}
   
        //Buffer a message for this element.
-       virtual CmiBool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
+       virtual bool deliver(CkArrayMessage *msg,CkDeliver_t type,int opts=0) {
                DEBS((AA" Queued message for %s\n"AB,idx2str(msg->array_index())));
                if (opts & CK_MSG_KEEP)
                        msg = (CkArrayMessage *)CkCopyMsg((void **)&msg);
@@ -1904,7 +1904,7 @@ public:
                envelope *env = UsrToEnv(msg);
                env->sender = CpvAccess(_currentObj)->mlogData->objID;
 #endif
-               return CmiTrue;
+               return true;
        }
  
        //This is called when this ArrayRec is about to be replaced.
@@ -1930,7 +1930,7 @@ public:
        }
   
        //Return if this element is now obsolete
-       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx) {
+       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx) {
                if (isStale() && buffer.length()>0) {
                        /*This indicates something is seriously wrong--
                          buffers should be short-lived.*/
@@ -1946,7 +1946,7 @@ public:
                        
                        // CkAbort("Stale array manager message(s)!\n");
                }
-               return CmiFalse;
+               return false;
        }
   
 /*  virtual void pup(PUP::er &p) {
@@ -2074,7 +2074,7 @@ CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkGroupID metalbID_,CkArra
        nManagers=0;
        firstManager=NULL;
        firstFree=localLen=0;
-       duringMigration=CmiFalse;
+       duringMigration=false;
        nSprings=0;
 #if !CMK_GLOBAL_LOCATION_UPDATE
        CcdCallOnConditionKeepOnPE(CcdPERIODIC_1minute,staticSpringCleaning,(void *)this, CkMyPe());
@@ -2111,7 +2111,7 @@ CkLocMgr::CkLocMgr(CkMigrateMessage* m)
        nManagers=0;
        firstManager=NULL;
        firstFree=localLen=0;
-       duringMigration=CmiFalse;
+       duringMigration=false;
        nSprings=0;
 #if !CMK_GLOBAL_LOCATION_UPDATE
        CcdCallOnConditionKeepOnPE(CcdPERIODIC_1minute,staticSpringCleaning,(void *)this, CkMyPe());
@@ -2308,8 +2308,8 @@ void CkLocMgr::informHome(const CkArrayIndex &idx,int nowOnPe)
 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
 CkLocRec_local *CkLocMgr::createLocal(const CkArrayIndex &idx,
-        CmiBool forMigration, CmiBool ignoreArrival,
-        CmiBool notifyHome,int dummy)
+        bool forMigration, bool ignoreArrival,
+        bool notifyHome,int dummy)
 {
     int localIdx=nextFree();
     DEBC((AA"Adding new record for element %s at local index %d\n"AB,idx2str(idx),localIdx));
@@ -2322,8 +2322,8 @@ CkLocRec_local *CkLocMgr::createLocal(const CkArrayIndex &idx,
 }
 #else
 CkLocRec_local *CkLocMgr::createLocal(const CkArrayIndex &idx, 
-               CmiBool forMigration, CmiBool ignoreArrival,
-               CmiBool notifyHome)
+               bool forMigration, bool ignoreArrival,
+               bool notifyHome)
 {
        int localIdx=nextFree();
        DEBC((AA"Adding new record for element %s at local index %d\n"AB,idx2str(idx),localIdx));
@@ -2337,7 +2337,7 @@ CkLocRec_local *CkLocMgr::createLocal(const CkArrayIndex &idx,
 #endif
 
 //Add a new local array element, calling element's constructor
-CmiBool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
+bool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
                CkMigratable *elt,int ctorIdx,void *ctorMsg)
 {
        CK_MAGICNUMBER_CHECK
@@ -2345,7 +2345,7 @@ CmiBool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
        CkLocRec_local *rec;
        if (oldRec==NULL||oldRec->type()!=CkLocRec::local) 
        { //This is the first we've heard of that element-- add new local record
-               rec=createLocal(idx,CmiFalse,CmiFalse,CmiTrue);
+               rec=createLocal(idx,false,false,true);
 #if CMK_GLOBAL_LOCATION_UPDATE
                 if (homePe(idx) != CkMyPe()) {
                   DEBC((AA"Global location broadcast for new element idx %s "
@@ -2359,13 +2359,13 @@ CmiBool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
                rec=((CkLocRec_local *)oldRec);
                rec->addedElement();
        }
-       if (!addElementToRec(rec,managers.find(id),elt,ctorIdx,ctorMsg)) return CmiFalse;
+       if (!addElementToRec(rec,managers.find(id),elt,ctorIdx,ctorMsg)) return false;
        elt->ckFinishConstruction();
-       return CmiTrue;
+       return true;
 }
 
 //As above, but shared with the migration code
-CmiBool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
+bool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
                CkMigratable *elt,int ctorIdx,void *ctorMsg)
 {//Insert the new element into its manager's local list
        int localIdx=rec->getLocalIndex();
@@ -2377,7 +2377,7 @@ CmiBool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
        CkMigratable_initInfo &i=CkpvAccess(mig_initInfo);
        i.locRec=rec;
        i.chareType=_entryTable[ctorIdx]->chareIdx;
-       if (!rec->invokeEntry(elt,ctorMsg,ctorIdx,CmiTrue)) return CmiFalse;
+       if (!rec->invokeEntry(elt,ctorMsg,ctorIdx,true)) return false;
 
 #if CMK_OUT_OF_CORE
        /* Register new element with out-of-core */
@@ -2385,7 +2385,7 @@ CmiBool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
        elt->prefetchObjID=CooRegisterObject(&CkArrayElementPrefetcher,p_getSize.size(),elt);
 #endif
        
-       return CmiTrue;
+       return true;
 }
 void CkLocMgr::updateLocation(const CkArrayIndex &idx,int nowOnPe) {
   inform(idx,nowOnPe);
@@ -2571,11 +2571,11 @@ int CkLocMgr::deliver(CkMessage *m,CkDeliver_t type,int opts) {
 #endif
        /**FAULT_EVAC*/
        if (rec!=NULL){
-               CmiBool result = rec->deliver(msg,type,opts);
-               // if result is CmiFalse, than rec is not valid anymore, as the object
+               bool result = rec->deliver(msg,type,opts);
+               // if result is false, than rec is not valid anymore, as the object
                // the message was just delivered to has died or migrated out.
                // Therefore rec->type() cannot be invoked!
-               if (result==CmiTrue && rec->type()==CkLocRec::local) return 0;
+               if (result==true && rec->type()==CkLocRec::local) return 0;
                else return 1;
                /*if(!result){
                        //DEBS((AA"deliver %s failed type %d \n"AB,idx2str(idx),rec->type()));
@@ -2596,7 +2596,7 @@ int CkLocMgr::deliver(CkMessage *m,CkDeliver_t type,int opts) {
 }
 
 /// This index is not hashed-- somehow figure out what to do.
-CmiBool CkLocMgr::deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts)
+bool CkLocMgr::deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts)
 {
        CK_MAGICNUMBER_CHECK
        const CkArrayIndex &idx=msg->array_index();
@@ -2606,7 +2606,7 @@ CmiBool CkLocMgr::deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts)
                DEBM((AA"Forwarding message for unknown %s to home %d \n"AB,idx2str(idx),onPe));
                msg->array_hops()++;
                CkArrayManagerDeliver(onPe,msg,opts);
-               return CmiTrue;
+               return true;
        }
        else
        { // We *are* the home processor:
@@ -2632,11 +2632,11 @@ CmiBool CkLocMgr::deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts)
              return demandCreateElement(msg,-1,type);
            }
          }
-         return CmiTrue;
+         return true;
        }
 }
 
-CmiBool CkLocMgr::demandCreateElement(CkArrayMessage *msg,int onPe,CkDeliver_t type)
+bool CkLocMgr::demandCreateElement(CkArrayMessage *msg,int onPe,CkDeliver_t type)
 {
        CK_MAGICNUMBER_CHECK
        const CkArrayIndex &idx=msg->array_index();
@@ -2716,7 +2716,7 @@ void CkLocMgr::iterate(CkLocIterator &dest) {
 /************************** LocMgr: MIGRATION *************************/
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
 void CkLocMgr::pupElementsFor(PUP::er &p,CkLocRec_local *rec,
-        CkElementCreation_t type, CmiBool create, int dummy)
+        CkElementCreation_t type, bool create, int dummy)
 {
     p.comment("-------- Array Location --------");
     register ManagerRec *m;
@@ -2743,7 +2743,7 @@ void CkLocMgr::pupElementsFor(PUP::er &p,CkLocRec_local *rec,
                     i.locRec=rec;
                     i.chareType=_entryTable[migCtorIdx]->chareIdx;
                     dummyElts.push_back(elt);
-                    if (!rec->invokeEntry(elt,NULL,migCtorIdx,CmiTrue)) return ;
+                    if (!rec->invokeEntry(elt,NULL,migCtorIdx,true)) return ;
                 }
         }
     }
@@ -2772,7 +2772,7 @@ void CkLocMgr::pupElementsFor(PUP::er &p,CkLocRec_local *rec,
 }
 #else
 void CkLocMgr::pupElementsFor(PUP::er &p,CkLocRec_local *rec,
-               CkElementCreation_t type,CmiBool rebuild)
+               CkElementCreation_t type,bool rebuild)
 {
        p.comment("-------- Array Location --------");
        register ManagerRec *m;
@@ -2937,11 +2937,11 @@ void CkLocMgr::emigrate(CkLocRec_local *rec,int toPe)
        thisProxy[toPe].immigrate(msg);
 //#endif
 
-       duringMigration=CmiTrue;
+       duringMigration=true;
        delete rec; //Removes elements, hashtable entries, local index
        
        
-       duringMigration=CmiFalse;
+       duringMigration=false;
        //The element now lives on another processor-- tell ourselves and its home
        inform(idx,toPe);
 //#if (!defined(_FAULT_MLOG_) && !defined(_FAULT_CAUSAL_))    
@@ -2991,9 +2991,9 @@ void CkLocMgr::immigrate(CkArrayElementMigrateMessage *msg)
        //Create a record for this element
 //#if (!defined(_FAULT_MLOG_) && !defined(_FAULT_CAUSAL_))    
 //#if !defined(_FAULT_MLOG_)     
-       CkLocRec_local *rec=createLocal(idx,CmiTrue,msg->ignoreArrival,CmiFalse /* home told on departure */ );
+       CkLocRec_local *rec=createLocal(idx,true,msg->ignoreArrival,false /* home told on departure */ );
 //#else
-//    CkLocRec_local *rec=createLocal(idx,CmiTrue,CmiTrue,CmiFalse /* home told on departure */ );
+//    CkLocRec_local *rec=createLocal(idx,true,true,false /* home told on departure */ );
 //#endif
        
        //Create the new elements as we unpack the message
@@ -3033,8 +3033,8 @@ void CkLocMgr::immigrate(CkArrayElementMigrateMessage *msg)
                int targetPE=getNextPE(idx);
                //set this flag so that load balancer is not informed when
                //this element migrates
-               rec->AsyncMigrate(CmiTrue);
-               rec->Bounced(CmiTrue);
+               rec->AsyncMigrate(true);
+               rec->Bounced(true);
                mgr->emigrate(rec,targetPE);
                
        }
@@ -3051,7 +3051,7 @@ void CkLocMgr::restore(const CkArrayIndex &idx, PUP::er &p)
        if(_BgOutOfCoreFlag!=2)
            CmiAbort("CkLocMgr::restore should only be used in out-of-core emulation for BigSim and be called when object is brought into memory!\n");
 #endif
-       CkLocRec_local *rec=createLocal(idx,CmiFalse,CmiFalse,CmiFalse);
+       CkLocRec_local *rec=createLocal(idx,false,false,false);
        
        //BIGSIM_OOC DEBUGGING
        //CkPrintf("Proc[%d]: Registering element %s with LDB\n", CkMyPe(), idx2str(idx));
@@ -3065,13 +3065,13 @@ void CkLocMgr::restore(const CkArrayIndex &idx, PUP::er &p)
 
 /// Insert and unpack this array element from this checkpoint (e.g., from CkLocation::pup)
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-void CkLocMgr::resume(const CkArrayIndex &idx, PUP::er &p, CmiBool create, int dummy)
+void CkLocMgr::resume(const CkArrayIndex &idx, PUP::er &p, bool create, int dummy)
 {
        CkLocRec_local *rec;
        CkLocRec *recGlobal;    
 
        if(create){
-               rec = createLocal(idx,CmiFalse,CmiFalse,CmiTrue && !dummy /* home doesn't know yet */,dummy );
+               rec = createLocal(idx,false,false,true && !dummy /* home doesn't know yet */,dummy );
        }else{
                recGlobal = elementNrec(idx);
                if(recGlobal == NULL) 
@@ -3088,9 +3088,9 @@ void CkLocMgr::resume(const CkArrayIndex &idx, PUP::er &p, CmiBool create, int d
     }
 }
 #else
-void CkLocMgr::resume(const CkArrayIndex &idx, PUP::er &p, CmiBool notify,CmiBool rebuild)
+void CkLocMgr::resume(const CkArrayIndex &idx, PUP::er &p, bool notify,bool rebuild)
 {
-       CkLocRec_local *rec=createLocal(idx,CmiFalse,CmiFalse,notify /* home doesn't know yet */ );
+       CkLocRec_local *rec=createLocal(idx,false,false,notify /* home doesn't know yet */ );
 
        //Create the new elements as we unpack the message
        pupElementsFor(p,rec,CkElementCreation_resume,rebuild);
@@ -3159,7 +3159,7 @@ static const char *rec2str[]={
 };
 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-void CkLocMgr::setDuringMigration(CmiBool _duringMigration){
+void CkLocMgr::setDuringMigration(bool _duringMigration){
     duringMigration = _duringMigration;
 }
 #endif
index 3eda4797632ab3c395d61bc656487c852cfeda32..4ae7c45c87098e9b5108bb948a4c84002572ec7b 100644 (file)
@@ -64,7 +64,7 @@ public:
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
         CkGroupID gid; //gid of location manager
 #endif
-       CmiBool bounced;
+       bool bounced;
        double* packData;
 };
 
@@ -144,14 +144,14 @@ public:
   virtual RecType type(void)=0;
   
   /// Accept a message for this element
-  virtual CmiBool deliver(CkArrayMessage *m,CkDeliver_t type,int opts=0)=0;
+  virtual bool deliver(CkArrayMessage *m,CkDeliver_t type,int opts=0)=0;
   
   /// This is called when this ArrayRec is about to be replaced.
   /// It is only used to deliver buffered element messages.
   virtual void beenReplaced(void);
   
   /// Return if this rec is now obsolete
-  virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx)=0; 
+  virtual bool isObsolete(int nSprings,const CkArrayIndex &idx)=0; 
 
   /// Return the represented array element; or NULL if there is none
   virtual CkMigratable *lookupElement(CkArrayID aid);
@@ -166,12 +166,12 @@ public:
 class CkLocRec_local : public CkLocRec {
   CkArrayIndex idx;/// Element's array index
   int localIdx; /// Local index (into array manager's element lists)
-  CmiBool running; /// True when inside a startTiming/stopTiming pair
-  CmiBool *deletedMarker; /// Set this if we're deleted during processing
+  bool running; /// True when inside a startTiming/stopTiming pair
+  bool *deletedMarker; /// Set this if we're deleted during processing
   CkQ<CkArrayMessage *> halfCreated; /// Stores messages for nonexistent siblings of existing elements
 public:
   //Creation and Destruction:
-  CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,CmiBool ignoreArrival,
+  CkLocRec_local(CkLocMgr *mgr,bool fromMigration,bool ignoreArrival,
        const CkArrayIndex &idx_,int localIdx_);
   void migrateMe(int toPe); //Leave this processor
   void informIdealLBPeriod(int lb_ideal_period);
@@ -186,17 +186,17 @@ public:
    *  Accept a message for this element.
    *  Returns false if the element died during the receive.
    */
-  virtual CmiBool deliver(CkArrayMessage *m,CkDeliver_t type,int opts=0);
+  virtual bool deliver(CkArrayMessage *m,CkDeliver_t type,int opts=0);
 
   /** Invoke the given entry method on this element.
    *   Returns false if the element died during the receive.
    *   If doFree is true, the message is freed after send;
    *    if false, the message can be reused.
    */
-  CmiBool invokeEntry(CkMigratable *obj,void *msg,int idx,CmiBool doFree);
+  bool invokeEntry(CkMigratable *obj,void *msg,int idx,bool doFree);
 
   virtual RecType type(void);
-  virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx);
+  virtual bool isObsolete(int nSprings,const CkArrayIndex &idx);
 
 #if CMK_LBDB_ON  //For load balancing:
   /// Control the load balancer:
@@ -225,39 +225,39 @@ public:
   void metaLBCallLBOnChares();
   void recvMigrate(int dest);
   void setMigratable(int migratable);  /// set migratable
-  void AsyncMigrate(CmiBool use);
-  CmiBool isAsyncMigrate()   { return asyncMigrate; }
-  void ReadyMigrate(CmiBool ready) { readyMigrate = ready; } ///called from user
+  void AsyncMigrate(bool use);
+  bool isAsyncMigrate()   { return asyncMigrate; }
+  void ReadyMigrate(bool ready) { readyMigrate = ready; } ///called from user
   int  isReadyMigrate()        { return readyMigrate; }
-  CmiBool checkBufferedMigration();    // check and execute pending migration
+  bool checkBufferedMigration();       // check and execute pending migration
   int   MigrateToPe();
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
         void Migrated();
 #endif
-  inline void setMeasure(CmiBool status) { enable_measure = status; }
+  inline void setMeasure(bool status) { enable_measure = status; }
 private:
   LBDatabase *the_lbdb;
   MetaBalancer *the_metalb;
   LDObjHandle ldHandle;
-  CmiBool  asyncMigrate;  /// if readyMove is inited
-  CmiBool  readyMigrate;    /// status whether it is ready to migrate
-  CmiBool  enable_measure;
+  bool  asyncMigrate;  /// if readyMove is inited
+  bool  readyMigrate;    /// status whether it is ready to migrate
+  bool  enable_measure;
   int  nextPe;              /// next migration dest processor
 #else
-  void AsyncMigrate(CmiBool use){};
+  void AsyncMigrate(bool use){};
 #endif
 /**FAULT_EVAC*/
 private:
-       CmiBool asyncEvacuate; //can the element be evacuated anytime, false for tcharm 
-       CmiBool bounced; //did this element try to immigrate into a processor which was evacuating
+       bool asyncEvacuate; //can the element be evacuated anytime, false for tcharm 
+       bool bounced; //did this element try to immigrate into a processor which was evacuating
                                                                                        // and was bounced away to some other processor. This is assumed to happen
                                                                                        //only if this object was migrated by a load balancer, but the processor
                                                                                        // started crashing soon after
 public:        
-       CmiBool isAsyncEvacuate(){return asyncEvacuate;}
-       void AsyncEvacuate(CmiBool set){asyncEvacuate = set;}
-       CmiBool isBounced(){return bounced;}
-       void Bounced(CmiBool set){bounced = set;}
+       bool isAsyncEvacuate(){return asyncEvacuate;}
+       void AsyncEvacuate(bool set){asyncEvacuate = set;}
+       bool isBounced(){return bounced;}
+       void Bounced(bool set){bounced = set;}
 };
 class CkLocRec_remote;
 
@@ -279,7 +279,7 @@ protected:
 private:
   int thisChareType;//My chare type
   void commonInit(void);
-  CmiBool asyncEvacuate;
+  bool asyncEvacuate;
   int atsync_iteration;
 
   enum state {
@@ -339,16 +339,16 @@ public:
 
   /// Execute the given entry method.  Returns false if the element 
   /// deleted itself or migrated away during execution.
-  inline CmiBool ckInvokeEntry(int epIdx,void *msg,CmiBool doFree) 
+  inline bool ckInvokeEntry(int epIdx,void *msg,bool doFree) 
          {return myRec->invokeEntry(this,msg,epIdx,doFree);}
 
 protected:
   /// A more verbose form of abort
   virtual void CkAbort(const char *str) const;
 
-  CmiBool usesAtSync;//You must set this in the constructor to use AtSync().
-  CmiBool usesAutoMeasure; //You must set this to use auto lb instrumentation.
-  CmiBool barrierRegistered;//True iff barrier handle below is set
+  bool usesAtSync;//You must set this in the constructor to use AtSync().
+  bool usesAutoMeasure; //You must set this to use auto lb instrumentation.
+  bool barrierRegistered;//True iff barrier handle below is set
 
 public:
   virtual void ResumeFromSync(void);
@@ -365,7 +365,7 @@ private: //Load balancer state:
   LDBarrierReceiver ldBarrierRecvHandle;//Transient (not migrated)  
   static void staticResumeFromSync(void* data);
 public:
-  void ReadyMigrate(CmiBool ready);
+  void ReadyMigrate(bool ready);
   void ckFinishConstruction(void);
   void setMigratable(int migratable);
 #else
@@ -382,13 +382,13 @@ private:
   friend void CkArrayPrefetch_writeToSwap(FILE *swapfile,void *objptr);
   friend void CkArrayPrefetch_readFromSwap(FILE *swapfile,void *objptr);
   int prefetchObjID; //From CooRegisterObject
-  CmiBool isInCore; //If true, the object is present in memory
+  bool isInCore; //If true, the object is present in memory
 #endif
 
   // FAULT_EVAC
-  void AsyncEvacuate(CmiBool set){myRec->AsyncEvacuate(set);asyncEvacuate = set;};
+  void AsyncEvacuate(bool set){myRec->AsyncEvacuate(set);asyncEvacuate = set;};
 public:
-  CmiBool isAsyncEvacuate(){return asyncEvacuate;};
+  bool isAsyncEvacuate(){return asyncEvacuate;};
 };
 
 /** 
@@ -527,7 +527,7 @@ public:
        /// Demand-create an element at this index on this processor
        ///  Returns true if the element was successfully added;
        ///  false if the element migrated away or deleted itself.
-       virtual CmiBool demandCreateElement(const CkArrayIndex &idx,
+       virtual bool demandCreateElement(const CkArrayIndex &idx,
                int onPe,int ctor,CkDeliver_t type) =0;
 };
 
@@ -549,7 +549,7 @@ public:
        CkLocMgr(CkGroupID map,CkGroupID _lbdb,CkArrayIndex& numInitial);
        CkLocMgr(CkMigrateMessage *m);
 
-       inline CmiBool isLocMgr(void) { return CmiTrue; }
+       inline bool isLocMgr(void) { return true; }
        CkGroupID &getGroupID(void) {return thisgroup;}
        inline CProxy_CkLocMgr &getProxy(void) {return thisProxy;}
        inline CProxyElement_CkLocMgr &getLocalProxy(void) {return thislocalproxy;}
@@ -567,7 +567,7 @@ public:
        /// Add a new local array element, calling element's constructor
        ///  Returns true if the element was successfully added;
        ///  false if the element migrated away or deleted itself.
-       CmiBool addElement(CkArrayID aid,const CkArrayIndex &idx, CkMigratable *elt,int ctorIdx,void *ctorMsg);
+       bool addElement(CkArrayID aid,const CkArrayIndex &idx, CkMigratable *elt,int ctorIdx,void *ctorMsg);
 
        ///Deliver message to this element:
        inline void deliverViaQueue(CkMessage *m) {deliver(m,CkDeliver_queue);}
@@ -619,13 +619,13 @@ public:
 
        int getSpringCount(void) const { return nSprings; }
 
-       CmiBool demandCreateElement(CkArrayMessage *msg,int onPe,CkDeliver_t type);
+       bool demandCreateElement(CkArrayMessage *msg,int onPe,CkDeliver_t type);
 
 //Interface used by external users:
        /// Home mapping
        inline int     homePe (const CkArrayIndex &idx) const {return map->homePe(mapHandle,idx);}
        inline int     procNum(const CkArrayIndex &idx) const {return map->procNum(mapHandle,idx);}
-       inline CmiBool isHome (const CkArrayIndex &idx) const {return (CmiBool)(homePe(idx)==CkMyPe());}
+       inline bool isHome (const CkArrayIndex &idx) const {return (bool)(homePe(idx)==CkMyPe());}
 
        /// Look up the object with this array index, or return NULL
        CkMigratable *lookup(const CkArrayIndex &idx,CkArrayID aid);
@@ -638,7 +638,7 @@ public:
 
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
        //mark the duringMigration variable .. used for parallel restart
-       void setDuringMigration(CmiBool _duringMigration);
+       void setDuringMigration(bool _duringMigration);
 #endif
 
        /// Pass each of our locations (each separate array index) to this destination.
@@ -648,9 +648,9 @@ public:
        void restore(const CkArrayIndex &idx, PUP::er &p);
        /// Insert and unpack this array element from this checkpoint (e.g., from CkLocation::pup)
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-       void resume(const CkArrayIndex &idx, PUP::er &p, CmiBool create, int dummy=0);
+       void resume(const CkArrayIndex &idx, PUP::er &p, bool create, int dummy=0);
 #else
-       void resume(const CkArrayIndex &idx, PUP::er &p, CmiBool notify=CmiTrue,CmiBool=CmiFalse);
+       void resume(const CkArrayIndex &idx, PUP::er &p, bool notify=true,bool=false);
 #endif
 
 //Communication:
@@ -689,10 +689,10 @@ private:
        friend class MemElementPacker;
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
        void pupElementsFor(PUP::er &p,CkLocRec_local *rec,
-        CkElementCreation_t type, CmiBool create=CmiTrue, int dummy=0);
+        CkElementCreation_t type, bool create=true, int dummy=0);
 #else
        void pupElementsFor(PUP::er &p,CkLocRec_local *rec,
-               CkElementCreation_t type,CmiBool rebuild = CmiFalse);
+               CkElementCreation_t type,bool rebuild = false);
 #endif
 
        /// Call this member function on each element of this location:
@@ -701,17 +701,17 @@ private:
        typedef void (CkMigratable::* CkMigratable_voidfn_arg_t)(void*);
        void callMethod(CkLocRec_local *rec,CkMigratable_voidfn_arg_t fn, void*);
 
-       CmiBool deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts);
+       bool deliverUnknown(CkArrayMessage *msg,CkDeliver_t type,int opts);
 
        /// Create a new local record at this array index.
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
 CkLocRec_local *createLocal(const CkArrayIndex &idx,
-        CmiBool forMigration, CmiBool ignoreArrival,
-        CmiBool notifyHome,int dummy=0);
+        bool forMigration, bool ignoreArrival,
+        bool notifyHome,int dummy=0);
 #else
        CkLocRec_local *createLocal(const CkArrayIndex &idx, 
-               CmiBool forMigration, CmiBool ignoreArrival,
-               CmiBool notifyHome);
+               bool forMigration, bool ignoreArrival,
+               bool notifyHome);
 #endif
 
 public:
@@ -737,7 +737,7 @@ public:
        int nManagers;
        ManagerRec *firstManager; //First non-null array manager
 
-       CmiBool addElementToRec(CkLocRec_local *rec,ManagerRec *m,
+       bool addElementToRec(CkLocRec_local *rec,ManagerRec *m,
                CkMigratable *elt,int ctorIdx,void *ctorMsg);
 
        //For keeping track of free local indices
@@ -753,7 +753,7 @@ public:
        CmiImmediateLockType hashImmLock;
 
        /// This flag is set while we delete an old copy of a migrator
-       CmiBool duringMigration;
+       bool duringMigration;
 
        //Occasionally clear out stale remote pointers
        static void staticSpringCleaning(void *mgr,double curWallTime);
index 7395cf02395c952aec93bc44e3a547d7920dd6ea..15436cbd18ae3c3182a3c49cf86de711a59c81d7 100644 (file)
@@ -394,9 +394,9 @@ void CkMemCheckPT::inmem_restore(CkArrayCheckPTMessage *m)
   CkLocMgr *mgr = CProxy_CkLocMgr(m->locMgr).ckLocalBranch();
   CmiAssert(mgr);
 #if !STREAMING_INFORMHOME && CK_NO_PROC_POOL
-  mgr->resume(m->index, p, CmiTrue);     // optimize notifyHome
+  mgr->resume(m->index, p, true);     // optimize notifyHome
 #else
-  mgr->resume(m->index, p, CmiFalse);     // optimize notifyHome
+  mgr->resume(m->index, p, false);     // optimize notifyHome
 #endif
 
   // find a list of array elements bound together
@@ -1109,9 +1109,9 @@ void CkMemCheckPT::recoverAll(CkArrayCheckPTMessage * msg,CkVec<CkGroupID> * gma
                        CkLocMgr * mgr = (CkLocMgr *)CkpvAccess(_groupTable)->find(gID).getObj();
                        int homePe = mgr->homePe(idx);
 #if !STREAMING_INFORMHOME && CK_NO_PROC_POOL
-                       mgr->resume(idx,p,CmiTrue,CmiTrue);
+                       mgr->resume(idx,p,true,true);
 #else
-                       mgr->resume(idx,p,CmiFalse,CmiTrue);
+                       mgr->resume(idx,p,false,true);
 #endif
 #if STREAMING_INFORMHOME && CK_NO_PROC_POOL
                        homePe = mgr->homePe(idx);
index d83a4b20a04a93302a699ebbaf5f95af21bc4635..60e46a0b5108fb06fe605a54592461a4017292bd 100644 (file)
@@ -874,11 +874,11 @@ void _startCheckpointHandler(CheckpointBarrierMsg *startMsg){
        }
        CkPupROData(psizer);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupGroupData(psizer,CmiTrue);
+       CkPupGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupNodeGroupData(psizer,CmiTrue);
+       CkPupNodeGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       pupArrayElementsSkip(psizer,CmiTrue,NULL);
+       pupArrayElementsSkip(psizer,true,NULL);
        DEBUG_MEM(CmiMemoryCheck());
 
        int dataSize = psizer.size();
@@ -896,9 +896,9 @@ void _startCheckpointHandler(CheckpointBarrierMsg *startMsg){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiTrue);
-       CkPupNodeGroupData(pBuf,CmiTrue);
-       pupArrayElementsSkip(pBuf,CmiTrue,NULL);
+       CkPupGroupData(pBuf,true);
+       CkPupNodeGroupData(pBuf,true);
+       pupArrayElementsSkip(pBuf,true,NULL);
 
        unAckedCheckpoint=1;
        CmiSetHandler(msg,_storeCheckpointHandlerIdx);
@@ -957,11 +957,11 @@ void startMlogCheckpoint(void *_dummy, double curWallTime){
        }
        CkPupROData(psizer);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupGroupData(psizer,CmiTrue);
+       CkPupGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       CkPupNodeGroupData(psizer,CmiTrue);
+       CkPupNodeGroupData(psizer,true);
        DEBUG_MEM(CmiMemoryCheck());
-       pupArrayElementsSkip(psizer,CmiTrue,NULL);
+       pupArrayElementsSkip(psizer,true,NULL);
        DEBUG_MEM(CmiMemoryCheck());
 
        int dataSize = psizer.size();
@@ -979,9 +979,9 @@ void startMlogCheckpoint(void *_dummy, double curWallTime){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiTrue);
-       CkPupNodeGroupData(pBuf,CmiTrue);
-       pupArrayElementsSkip(pBuf,CmiTrue,NULL);
+       CkPupGroupData(pBuf,true);
+       CkPupNodeGroupData(pBuf,true);
+       pupArrayElementsSkip(pBuf,true,NULL);
 
        unAckedCheckpoint=1;
        CmiSetHandler(msg,_storeCheckpointHandlerIdx);
@@ -1026,7 +1026,7 @@ public:
 /**
  * Pups all the array elements in this processor.
  */
-void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSkip,int listsize){
+void pupArrayElementsSkip(PUP::er &p, bool create, MigrationRecord *listToSkip,int listsize){
        int numElements,i;
        int numGroups = CkpvAccess(_groupIDTable)->size();      
        if(!p.isUnpacking()){
@@ -1254,9 +1254,9 @@ void _recvCheckpointHandler(char *_restartData){
                pBuf | CpvAccess(_incarnation)[i];
        }
        CkPupROData(pBuf);
-       CkPupGroupData(pBuf,CmiTrue);
-       CkPupNodeGroupData(pBuf,CmiTrue);
-       pupArrayElementsSkip(pBuf,CmiTrue,NULL);
+       CkPupGroupData(pBuf,true);
+       CkPupNodeGroupData(pBuf,true);
+       pupArrayElementsSkip(pBuf,true,NULL);
        CkAssert(pBuf.size() == restartData->checkPointSize);
        printf("[%d] Restart Objects created from CheckPointData at %.6lf \n",CkMyPe(),CmiWallTimer());
 
@@ -1463,9 +1463,9 @@ public:
                pmem.becomeDeleting();
                pupLocation(loc,pmem);
                        
-               locMgr->setDuringMigration(CmiTrue);
+               locMgr->setDuringMigration(true);
                delete rec;
-               locMgr->setDuringMigration(CmiFalse);
+               locMgr->setDuringMigration(false);
                locMgr->inform(idx,*targetPE);
 
                CmiSetHandler(msg,_distributedLocationHandlerIdx);
@@ -1507,7 +1507,7 @@ void _sendBackLocationHandler(char *receivedMsg){
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
        donotCountMigration=1;
-       mgr->resume(idx,pmem,CmiTrue);
+       mgr->resume(idx,pmem,true);
        donotCountMigration=0;
        informLocationHome(gID,idx,mgr->homePe(idx),CkMyPe());
        printf("Array element inserted at processor %d after parallel recovery\n",CkMyPe());
@@ -1544,7 +1544,7 @@ void _distributedLocationHandler(char *receivedMsg){
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
        donotCountMigration=1;
-       mgr->resume(idx,pmem,CmiTrue);
+       mgr->resume(idx,pmem,true);
        donotCountMigration=0;
        informLocationHome(gID,idx,mgr->homePe(idx),CkMyPe());
        printf("Array element inserted at processor %d after distribution at restart ",CkMyPe());
@@ -1757,9 +1757,9 @@ void sendBackImmigrantRecObjs(){
                pmem.becomeDeleting();
                pupLocation(loc,locMgr,pmem);
                
-               locMgr->setDuringMigration(CmiTrue);
+               locMgr->setDuringMigration(true);
                delete rec;
-               locMgr->setDuringMigration(CmiFalse);
+               locMgr->setDuringMigration(false);
                locMgr->inform(idx,targetPE);
 
                // sending the object
index 1c4b895e69bd2885a2b1bbb3f01a4ba12e984c42..5f3201b0d51bca316726e02b7c11265b16893377 100644 (file)
@@ -413,7 +413,7 @@ CpvExtern(StoredCheckpoint *,_storedCheckpointData);
 void CkStartMlogCheckpoint(CkCallback &cb);
 void checkpointAlarm(void *_dummy,double curWallTime);
 void startMlogCheckpoint(void *_dummy,double curWallTime);
-void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSkip,int listSize=0);
+void pupArrayElementsSkip(PUP::er &p, bool create, MigrationRecord *listToSkip,int listSize=0);
 
 //handler functions for checkpoint
 void _checkpointRequestHandler(CheckpointRequest *request);
index 07853a241452c22c1a3e8244304dabca5c58f6a0..0ffc01b43e64fd413ff2665d2a090e91943ed6ad 100644 (file)
@@ -188,9 +188,9 @@ CkReductionMgr::CkReductionMgr()//Constructor
 #endif
   redNo=0;
   completedRedNo = -1;
-  inProgress=CmiFalse;
-  creating=CmiFalse;
-  startRequested=CmiFalse;
+  inProgress=false;
+  creating=false;
+  startRequested=false;
   gcount=lcount=0;
   nContrib=nRemote=0;
   maxStartRequest=0;
@@ -198,7 +198,7 @@ CkReductionMgr::CkReductionMgr()//Constructor
        numImmigrantRecObjs = 0;
        numEmigrantRecObjs = 0;
 #endif
-  disableNotifyChildrenStart = CmiFalse;
+  disableNotifyChildrenStart = false;
 
   barrier_gCount=0;
   barrier_nSource=0;
@@ -211,9 +211,9 @@ CkReductionMgr::CkReductionMgr(CkMigrateMessage *m) :CkGroupInitCallback(m)
 {
   redNo=0;
   completedRedNo = -1;
-  inProgress=CmiFalse;
-  creating=CmiFalse;
-  startRequested=CmiFalse;
+  inProgress=false;
+  creating=false;
+  startRequested=false;
   gcount=lcount=0;
   nContrib=nRemote=0;
   maxStartRequest=0;
@@ -235,9 +235,9 @@ void CkReductionMgr::flushStates()
   // CmiPrintf("[%d] CkReductionMgr::flushState\n", CkMyPe());
   redNo=0;
   completedRedNo = -1;
-  inProgress=CmiFalse;
-  creating=CmiFalse;
-  startRequested=CmiFalse;
+  inProgress=false;
+  creating=false;
+  startRequested=false;
   nContrib=nRemote=0;
   maxStartRequest=0;
 
@@ -286,12 +286,12 @@ void contributorInfo::pup(PUP::er &p)
 void CkReductionMgr::creatingContributors(void)
 {
   DEBR((AA"Creating contributors...\n"AB));
-  creating=CmiTrue;
+  creating=true;
 }
 void CkReductionMgr::doneCreatingContributors(void)
 {
   DEBR((AA"Done creating contributors...\n"AB));
-  creating=CmiFalse;
+  creating=false;
   if (startRequested) startReduction(redNo,CkMyPe());
   finishReduction();
 }
@@ -516,13 +516,13 @@ void CkReductionMgr::startReduction(int number,int srcPE)
   if (creating) //Don't start yet-- we're creating elements
   {
     DEBR((AA"Postponing start request #%d until we're done creating\n"AB,redNo));
-    startRequested=CmiTrue;
+    startRequested=true;
     return;
   }
 
 //If none of these cases, we need to start the reduction--
   DEBR((AA"Starting reduction #%d  %d %d \n"AB,redNo,completedRedNo,number));
-  inProgress=CmiTrue;
+  inProgress=true;
  
 
        /*
@@ -724,8 +724,8 @@ void CkReductionMgr::finishReduction(void)
        adjVec.length()--;  
   }
 
-  inProgress=CmiFalse;
-  startRequested=CmiFalse;
+  inProgress=false;
+  startRequested=false;
   nRemote=nContrib=0;
 
   //Look through the future queue for messages we can now handle
@@ -1193,9 +1193,9 @@ int CkReductionMgr::treeRoot(void)
 {
   return 0;
 }
-CmiBool CkReductionMgr::hasParent(void) //Root Node
+bool CkReductionMgr::hasParent(void) //Root Node
 {
-  return (CmiBool)(CkMyPe()!=treeRoot());
+  return (bool)(CkMyPe()!=treeRoot());
 }
 int CkReductionMgr::treeParent(void) //My parent Node
 {
@@ -1681,16 +1681,16 @@ CkNodeReductionMgr::CkNodeReductionMgr()//Constructor
 #endif
   storedCallback=NULL;
   redNo=0;
-  inProgress=CmiFalse;
+  inProgress=false;
   
-  startRequested=CmiFalse;
+  startRequested=false;
   gcount=CkNumNodes();
   lcount=1;
   nContrib=nRemote=0;
   lockEverything = CmiCreateLock();
 
 
-  creating=CmiFalse;
+  creating=false;
   interrupt = 0;
   DEBR((AA"In NodereductionMgr constructor at %d \n"AB,this));
        /*
@@ -1707,14 +1707,14 @@ void CkNodeReductionMgr::flushStates()
  if(CkMyRank() == 0){
   // CmiPrintf("[%d] CkNodeReductionMgr::flushState\n", CkMyPe());
   redNo=0;
-  inProgress=CmiFalse;
+  inProgress=false;
 
-  startRequested=CmiFalse;
+  startRequested=false;
   gcount=CkNumNodes();
   lcount=1;
   nContrib=nRemote=0;
 
-  creating=CmiFalse;
+  creating=false;
   interrupt = 0;
   while (!msgs.isEmpty()) { delete msgs.deq(); }
   while (!futureMsgs.isEmpty()) delete futureMsgs.deq();
@@ -1882,13 +1882,13 @@ void CkNodeReductionMgr::startReduction(int number,int srcNode)
        if (creating) //Don't start yet-- we're creating elements
        {
                DEBR((AA" Node Postponing start request #%d until we're done creating\n"AB,redNo));
-               startRequested=CmiTrue;
+               startRequested=true;
                return;
        }
        
        //If none of these cases, we need to start the reduction--
        DEBR((AA"Starting Node reduction #%d on %p srcNode %d\n"AB,redNo,this,srcNode));
-       inProgress=CmiTrue;
+       inProgress=true;
 
        if(!_isNotifyChildInRed) return;
 
@@ -2067,8 +2067,8 @@ void CkNodeReductionMgr::finishReduction(void)
   redNo++;
        updateTree();
   int i;
-  inProgress=CmiFalse;
-  startRequested=CmiFalse;
+  inProgress=false;
+  startRequested=false;
   nRemote=nContrib=0;
 
   //Look through the future queue for messages we can now handle
@@ -2173,9 +2173,9 @@ int CkNodeReductionMgr::treeRoot(void)
 {
   return 0;
 }
-CmiBool CkNodeReductionMgr::hasParent(void) //Root Node
+bool CkNodeReductionMgr::hasParent(void) //Root Node
 {
-  return (CmiBool)(CkMyNode()!=treeRoot());
+  return (bool)(CkMyNode()!=treeRoot());
 }
 int CkNodeReductionMgr::treeParent(void) //My parent Node
 {
index 5cb732b28ef2a08b7f56165ff3771338ee601246..be5ee07c8609e25c2b417c1426e13e4b22f8e565 100644 (file)
@@ -352,9 +352,9 @@ private:
        CkCallback *storedCallback;
 
        int redNo;//Number of current reduction (incremented at end)
-       CmiBool inProgress;//Is a reduction started, but not complete?
-       CmiBool creating;//Are elements still being created?
-       CmiBool startRequested;//Should we start the next reduction when creation finished?
+       bool inProgress;//Is a reduction started, but not complete?
+       bool creating;//Are elements still being created?
+       bool startRequested;//Should we start the next reduction when creation finished?
        int gcount;
        int lcount;//Number of local contributors
 
@@ -399,7 +399,7 @@ private:
        void init_BinaryTree();
        enum {TREE_WID=2};
        int treeRoot(void);//Root PE
-       CmiBool hasParent(void);
+       bool hasParent(void);
        int treeParent(void);//My parent PE
        int firstKid(void);//My first child PE
        int treeKids(void);//Number of children in tree
@@ -408,9 +408,9 @@ private:
        CkReductionMsg *reduceMessages(void);
 
        //Map reduction number to a time
-       CmiBool isPast(int num) const {return (CmiBool)(num<redNo);}
-       CmiBool isPresent(int num) const {return (CmiBool)(num==redNo);}
-       CmiBool isFuture(int num) const {return (CmiBool)(num>redNo);}
+       bool isPast(int num) const {return (bool)(num<redNo);}
+       bool isPresent(int num) const {return (bool)(num==redNo);}
+       bool isFuture(int num) const {return (bool)(num>redNo);}
 
        /*FAULT_EVAC*/
        bool oldleaf;
@@ -540,7 +540,7 @@ public:
         void addBarrier(CkReductionMsg *m);
         void finishBarrier(void);
 
-       virtual CmiBool isReductionMgr(void){ return CmiTrue; }
+       virtual bool isReductionMgr(void){ return true; }
        virtual void flushStates();
        /*FAULT_EVAC: used to get the gcount on a processor when 
                it is evacuated.
@@ -584,9 +584,9 @@ private:
 
        int redNo;//Number of current reduction (incremented at end) to be deposited with NodeGroups
        int completedRedNo;//Number of reduction Completed ie recieved callback from NodeGroups
-       CmiBool inProgress;//Is a reduction started, but not complete?
-       CmiBool creating;//Are elements still being created?
-       CmiBool startRequested;//Should we start the next reduction when creation finished?
+       bool inProgress;//Is a reduction started, but not complete?
+       bool creating;//Are elements still being created?
+       bool startRequested;//Should we start the next reduction when creation finished?
        int gcount;//=el't created here - el't deleted here
        int lcount;//Number of local contributors
        int maxStartRequest; // the highest future ReductionStarting message received
@@ -628,7 +628,7 @@ private:
        void init_BinaryTree();
        enum {TREE_WID=2};
        int treeRoot(void);//Root PE
-       CmiBool hasParent(void);
+       bool hasParent(void);
        int treeParent(void);//My parent PE
        int firstKid(void);//My first child PE
        int treeKids(void);//Number of children in tree
@@ -637,9 +637,9 @@ private:
        CkReductionMsg *reduceMessages(void);
 
        //Map reduction number to a time
-       CmiBool isPast(int num) const {return (CmiBool)(num<redNo);}
-       CmiBool isPresent(int num) const {return (CmiBool)(num==redNo);}
-       CmiBool isFuture(int num) const {return (CmiBool)(num>redNo);}
+       bool isPast(int num) const {return (bool)(num<redNo);}
+       bool isPresent(int num) const {return (bool)(num==redNo);}
+       bool isFuture(int num) const {return (bool)(num>redNo);}
 
 
        //This vector of adjustments is indexed by redNo,
@@ -652,7 +652,7 @@ private:
 
 protected:
        //whether to notify children that reduction starts
-       CmiBool disableNotifyChildrenStart;
+       bool disableNotifyChildrenStart;
        void resetCountersWhenFlushingStates() { gcount = lcount = 0; }
 
 //Checkpointing utilities
index cd5ff2acfa301565f13e95b46781901dccb4ef76..835e60a187a4bf5628891f075ba24edff17c35a8 100644 (file)
@@ -774,7 +774,7 @@ static void _call_freeze_on_break_point(void * msg, void * object)
 
   // If the counter "skipBreakpoint" is not zero we actually do not freeze and deliver the regular message
   EntryInfo * breakPointEntryInfo = CpvAccess(breakPointEntryTable)->get(CkMessageToEpIdx(msg));
-  if (CkpvAccess(skipBreakpoint) > 0 || CkpvAccess(_debugEntryTable)[CkMessageToEpIdx(msg)].isBreakpoint==CmiFalse) {
+  if (CkpvAccess(skipBreakpoint) > 0 || CkpvAccess(_debugEntryTable)[CkMessageToEpIdx(msg)].isBreakpoint==false) {
     CkAssert(breakPointEntryInfo != NULL);
     breakPointEntryInfo->call(msg, object);
     if (CkpvAccess(skipBreakpoint) > 0) CkpvAccess(skipBreakpoint) --;
@@ -889,7 +889,7 @@ void CpdSetBreakPoint (char *msg)
              //CkAssert(breakPointEntryInfo->msgIdx == _entryTable[tableIdx]->msgIdx);
              //CkAssert(breakPointEntryInfo->chareIdx == _entryTable[tableIdx]->chareIdx);
            }
-           CkpvAccess(_debugEntryTable)[tableIdx].isBreakpoint = CmiTrue;
+           CkpvAccess(_debugEntryTable)[tableIdx].isBreakpoint = true;
            reply = ~0;
       }
     }
@@ -922,7 +922,7 @@ void CpdRemoveBreakPoint (char *msg)
             _entryTable[idx]->call = (CkCallFnPtr)breakPointEntryInfo->call;
           }
           reply = ~0 ;
-          CkpvAccess(_debugEntryTable)[idx].isBreakpoint = CmiFalse;
+          CkpvAccess(_debugEntryTable)[idx].isBreakpoint = false;
           //CmiPrintf("Breakpoint is removed for function %s with epIdx %ld\n", _entryTable[idx]->name, idx);
           //CkpvAccess(breakPointEntryTable)->remove(idx);
         }
@@ -948,7 +948,7 @@ void CpdRemoveAllBreakPoints ()
       _entryTable[idx]->name =  breakPointEntryInfo->name;
       _entryTable[idx]->call = (CkCallFnPtr)breakPointEntryInfo->call;
     }
-    CkpvAccess(_debugEntryTable)[idx].isBreakpoint = CmiFalse;
+    CkpvAccess(_debugEntryTable)[idx].isBreakpoint = false;
   }
   CcsSendReply(sizeof(int), (void*)&reply);
 }
index 09faf37bf400697f2067b43450ed274e520aa4fb..4f898b796518c2dd7199b1cbfb44a4102818a629 100644 (file)
@@ -42,11 +42,11 @@ typedef struct DebugPersistentCheck {
 class DebugEntryInfo {
 public:
   // true if this entry method has a breakpoint set
-  CmiBool isBreakpoint;
+  bool isBreakpoint;
   CkVec<DebugPersistentCheck> preProcess;
   CkVec<DebugPersistentCheck> postProcess;
 
-  DebugEntryInfo() : isBreakpoint(CmiFalse) { }
+  DebugEntryInfo() : isBreakpoint(false) { }
 };
 
 typedef CkVec<DebugEntryInfo> DebugEntryTable;
index 53cc2f25188d1bb57093ecb97ac87093409f534b..7ecf6948eb0674171374d19502487c9a38610069 100644 (file)
@@ -47,16 +47,16 @@ int CkRegisterEp(const char *name, CkCallFnPtr call, int msgIdx, int chareIdx,
        int ck_ep_flags)
 {
   EntryInfo *e = new EntryInfo(name, call?call:ckInvalidCallFn, msgIdx, chareIdx);
-  if (ck_ep_flags & CK_EP_NOKEEP) e->noKeep=CmiTrue;
-  if (ck_ep_flags & CK_EP_INTRINSIC) e->inCharm=CmiTrue;
-  if (ck_ep_flags & CK_EP_TRACEDISABLE) e->traceEnabled=CmiFalse;
+  if (ck_ep_flags & CK_EP_NOKEEP) e->noKeep=true;
+  if (ck_ep_flags & CK_EP_INTRINSIC) e->inCharm=true;
+  if (ck_ep_flags & CK_EP_TRACEDISABLE) e->traceEnabled=false;
 #if ADAPT_SCHED_MEM
   if (ck_ep_flags & CK_EP_MEMCRITICAL){
-     e->isMemCritical=CmiTrue;
+     e->isMemCritical=true;
      if (CkMyRank()==0)
         numMemCriticalEntries++;
   }else{
-    e->isMemCritical=CmiFalse;
+    e->isMemCritical=false;
   }
 #endif
   return _entryTable.add(e);
@@ -70,7 +70,7 @@ int CkRegisterChare(const char *name, size_t dataSz, ChareType chareType)
 
 extern "C"
 void CkRegisterChareInCharm(int chareIndex){
-  _chareTable[chareIndex]->inCharm = CmiTrue;
+  _chareTable[chareIndex]->inCharm = true;
 }
 
 extern "C"
@@ -137,13 +137,13 @@ void CkRegisterMessagePupFn(int epIndex,CkMessagePupFn m)
 extern "C"
 int CkDisableTracing(int epIdx) {
        int oldStatus = _entryTable[epIdx]->traceEnabled;
-       _entryTable[epIdx]->traceEnabled=CmiFalse;
+       _entryTable[epIdx]->traceEnabled=false;
        return oldStatus;
 }
 
 extern "C"
 void CkEnableTracing(int epIdx) {
-       _entryTable[epIdx]->traceEnabled=CmiTrue;
+       _entryTable[epIdx]->traceEnabled=true;
 }
 
 #if CMK_CHARMDEBUG
index 9e3b51eb808172bfe1c620ceccc0426712cec2df..55d6318cbd5d019dc8af4d501b5ae4bc80169df4 100644 (file)
@@ -53,15 +53,15 @@ class EntryInfo {
     /// Our chare's index into the _chareTable
     int chareIdx;
     /// Charm++ Tracing enabled for this ep (can change dynamically)
-    CmiBool traceEnabled; 
+    bool traceEnabled; 
     /// Method doesn't keep (and delete) message passed in to it.
-    CmiBool noKeep; 
+    bool noKeep; 
     /// true if this EP is charm internal functions
-    CmiBool inCharm;
+    bool inCharm;
     
 #ifdef ADAPT_SCHED_MEM
    /// true if this EP is used to be rescheduled when adjusting memory usage
-   CmiBool isMemCritical;
+   bool isMemCritical;
 #endif
     /** 
       A "marshall unpack" function:
@@ -88,7 +88,7 @@ class EntryInfo {
     EntryInfo(const char *n, CkCallFnPtr c, int m, int ci) : 
       name(n), call(c), msgIdx(m), chareIdx(ci), 
       marshallUnpack(0), messagePup(0)
-    { traceEnabled=CmiTrue; noKeep=CmiFalse; inCharm=CmiFalse;}
+    { traceEnabled=true; noKeep=false; inCharm=false;}
 };
 
 /**
@@ -160,7 +160,7 @@ class ChareInfo {
     ChareType  chareType;
 
     /// true if this EP is charm internal functions
-    CmiBool inCharm;
+    bool inCharm;
 
     int mainChareIdx;      
 
@@ -168,7 +168,7 @@ class ChareInfo {
       defCtor=migCtor=-1;
       isIrr = numbases = 0;
       chareType = t;
-      inCharm = CmiFalse;
+      inCharm = false;
       mainChareIdx = -1;
     }
     void setDefaultCtor(int idx) { defCtor = idx; }
@@ -176,8 +176,8 @@ class ChareInfo {
     void setMigCtor(int idx) { migCtor = idx; }
     int getMigCtor(void) { return migCtor; }
     void addBase(int idx) { bases[numbases++] = idx; }
-    void setInCharm() { inCharm = CmiTrue; }
-    CmiBool isInCharm() { return inCharm; }
+    void setInCharm() { inCharm = true; }
+    bool isInCharm() { return inCharm; }
     void setMainChareType(int idx) { mainChareIdx = idx; }
     int mainChareType() { return mainChareIdx; }
 };
index 13579d71b75c2120f49a5ac61f7bcd162a21f860..4d9db8dd0e4f177550c99a10a928041b4542e361 100644 (file)
@@ -206,7 +206,7 @@ public:
 
         myInst.setSourcePe();
 
-        usesAtSync = CmiTrue;
+        usesAtSync = true;
         setMigratable(true);
 
         arrd = arr;
index 48b8aa03dfff54adb0f04c4117e89c4f3f75fd47..893bd2c403dae8b89a49f8a13cb4f4cebd7b8ccb 100644 (file)
@@ -217,7 +217,7 @@ public:
         for(int count = 0; count < nElements; count ++) 
             elem_array[count] = CkArrayIndex1D(count);
         
-        usesAtSync = CmiTrue;
+        usesAtSync = true;
         setMigratable(true);
         myinst = cinst;
     }
index 13c26f6c1b3266822d5161ecbb2983e7d873b253..25661bf38bb185012cfe32c1c777d63d1865a153 100644 (file)
@@ -213,7 +213,7 @@ public:
         ComlibResetSectionProxy(&sproxy);
         ComlibDelegateProxy(&sproxy);
 
-        usesAtSync = CmiTrue;
+        usesAtSync = true;
         setMigratable(true);
         myinst = cinst;
     }
index 1bdfd66f3b877d5321c54bbe565d51cb366c4464..c36eb6f2166db16cadfea502263c4e2f722bda1b 100644 (file)
@@ -373,7 +373,7 @@ Jacobi::Jacobi() {
       imsg = 0;
       constrainBC();
 
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
       neighbors = 6;
       if(thisIndex.x == 0) 
           neighbors--;
index 1e48538a6d6ebb9e1dc030718389f27e021f6cb5..242039637df7d252f8d8d2a2c9c138a30ed64f91 100644 (file)
@@ -142,7 +142,7 @@ Jacobi::Jacobi() {
       imsg = 0;
       constrainBC();
 
-      usesAtSync = CmiTrue;
+      usesAtSync = true;
       neighbors = 6;
       if(thisIndex.x == 0) 
           neighbors--;
index e75516bb5d0e376bd9bce1b60fe4340dd37c3d0c..ff47c446a3e329aa8febeb54c53bf860ec9db3e3 100644 (file)
@@ -272,7 +272,7 @@ class Jacobi: public CBase_Jacobi {
       imsg = 0;
       constrainBC();
        
-               usesAtSync = CmiTrue;
+               usesAtSync = true;
 
     }
 
index e3efe84ddd1a81a78b387fb533a0b5436be7b819..de62a3d4edbfcf94c86f13f90bd386cc0fc4f73c 100644 (file)
@@ -252,7 +252,7 @@ class Jacobi: public CBase_Jacobi {
        imsg = 0;
        constrainBC();
 
-               usesAtSync = CmiTrue;
+               usesAtSync = true;
     }
 
     Jacobi(CkMigrateMessage* m): CBase_Jacobi(m) {}
index 3f8ed2ac0dd01feca70bf2fa5d6db95626803c12..846d7ef9fb6ee8cf3e00aee8afa07a9660793ef2 100644 (file)
@@ -184,7 +184,7 @@ public:
     for(i=0; i < future_bufsz; i++)
       future_receives[i]=0;
        
-    usesAtSync=CmiTrue;
+    usesAtSync = true;
 
     contribute(sizeof(i), &i, CkReduction::sum_int);
   }