clean code: bool => CmiBool
authorGengbin Zheng <gzheng@illinois.edu>
Sun, 10 Feb 2002 06:58:39 +0000 (06:58 +0000)
committerGengbin Zheng <gzheng@illinois.edu>
Sun, 10 Feb 2002 06:58:39 +0000 (06:58 +0000)
fixed compiler error on net-irix.

src/ck-core/charm++.h
src/ck-core/charm.h
src/ck-core/ckarray.C
src/ck-core/ckarray.h
src/ck-core/cklocation.C
src/ck-core/cklocation.h

index 904c97be1ae29db04764e737be4c2c3507e1300d..83bd75ffd0d6bab94186f91df92e0f100cb43509 100644 (file)
@@ -15,6 +15,8 @@
 #if CMK_NAMESPACES_BROKEN
 # if CMK_BLUEGENE_CHARM
 #  error "BLUEGENE Charm++ cannot be compiled without namespace support"
+# else
+#  include "middle.h"
 # endif
 #else
 # if CMK_BLUEGENE_CHARM
@@ -76,11 +78,18 @@ class CkMarshalledMessage {
 PUPmarshall(CkMarshalledMessage);
 
 /********************* Superclass of all Chares ******************/
+#if CMK_MULTIPLE_DELETE
 #define CHARM_INPLACE_NEW \
     void *operator new(size_t, void *ptr) { return ptr; }; \
     void operator delete(void*, void*) {}; \
     void *operator new(size_t s) { return malloc(s); } \
     void operator delete(void *ptr) { free(ptr); }
+#else
+#define CHARM_INPLACE_NEW \
+    void *operator new(size_t, void *ptr) { return ptr; }; \
+    void *operator new(size_t s) { return malloc(s); } \
+    void operator delete(void *ptr) { free(ptr); }
+#endif
 
 class Chare {
   protected:
@@ -105,7 +114,7 @@ class IrrGroup : public Chare {
     inline CmiBool ckTracingEnabled(void) {return ckEnableTracing;}
 
     IrrGroup(CkMigrateMessage *m) { }
-    IrrGroup() { thisgroup = CkGetGroupID(); ckEnableTracing=true; }
+    IrrGroup() { thisgroup = CkGetGroupID(); ckEnableTracing=CmiTrue; }
     virtual ~IrrGroup(); //<- needed for *any* child to have a virtual destructor
 
     virtual void pup(PUP::er &p);//<- pack/unpack routine
@@ -349,7 +358,7 @@ public:
        CkArrayID() : _gid() { }
        CkArrayID(CkGroupID g) :_gid(g) {}
        inline void setZero(void) {_gid.setZero();}
-       inline bool isZero(void) const {return _gid.isZero();}
+       inline int isZero(void) const {return _gid.isZero();}
        operator CkGroupID() const {return _gid;}
        CkArray *ckLocalBranch(void) const
                { return (CkArray *)CkLocalBranch(_gid); }
index a7e6e67455ea4c9ebe0a261090a57a0dffeb30b3..cde3227d873425d5289febfa79fcc82e906d0479 100644 (file)
@@ -100,7 +100,7 @@ typedef struct _ckGroupID{
   void pup(PUP::er &p) { p(pe); p(idx); }
   int isZero(void) const { return (idx==0); }
   void setZero(void) { idx=0; }
-  CmiBool operator==(const struct _ckGroupID& gid) const { 
+  int operator==(const struct _ckGroupID& gid) const { 
     return ((gid.pe==pe) && (gid.idx==idx));
   }
 #endif
index a3bd54043e41cd1bbddea28bb2d338d9c662e650..a1f3de9a72d56ab7e73c1d2a643a8b843470609c 100644 (file)
@@ -79,7 +79,7 @@ public:
   CkArray *thisArray;
   CkArrayID thisArrayID;
   int bcastNo,numInitial;
-  bool fromMigration;
+  CmiBool fromMigration;
 };
 
 CkpvStaticDeclare(ArrayElement_initInfo,initInfo);
@@ -306,9 +306,9 @@ CkArray::CkArray(const CkArrayOptions &c,CkMarshalledMessage &initMsg)
 
 CkMigratable *CkArray::allocateMigrated(int elChareType,const CkArrayIndex &idx) 
 {
-       return allocate(elChareType,idx,-1,true);
+       return allocate(elChareType,idx,-1,CmiTrue);
 }
-ArrayElement *CkArray::allocate(int elChareType,const CkArrayIndex &idx,int bcast,bool fromMigration) 
+ArrayElement *CkArray::allocate(int elChareType,const CkArrayIndex &idx,int bcast,CmiBool fromMigration) 
 {
        //Stash the element's initialization information in the global "initInfo"
        ArrayElement_initInfo &init=CkpvAccess(initInfo);
@@ -324,17 +324,17 @@ ArrayElement *CkArray::allocate(int elChareType,const CkArrayIndex &idx,int bcas
 }
 
 //This method is called by the user to add an element.
-bool CkArray::insertElement(CkMessage *me)
+CmiBool CkArray::insertElement(CkMessage *me)
 {
   magic.check();
   CkArrayMessage *m=(CkArrayMessage *)me;
   const CkArrayIndex &idx=m->array_index();
   int ctorIdx=m->array_ep();
   int chareType=_entryTable[ctorIdx]->chareIdx;
-  ArrayElement *elt=allocate(chareType,idx,UsrToEnv(m)->array_broadcastCount(),false);
-  if (!locMgr->addElement(thisgroup,idx,elt,ctorIdx,(void *)m)) return false;
-  if (!bringBroadcastUpToDate(elt)) return false;
-  return true;
+  ArrayElement *elt=allocate(chareType,idx,UsrToEnv(m)->array_broadcastCount(),CmiFalse);
+  if (!locMgr->addElement(thisgroup,idx,elt,ctorIdx,(void *)m)) return CmiFalse;
+  if (!bringBroadcastUpToDate(elt)) return CmiFalse;
+  return CmiTrue;
 }
 
 void CProxy_ArrayBase::doneInserting(void)
@@ -361,7 +361,7 @@ void CkArray::remoteDoneInserting(void)
   }
 }
 
-bool CkArray::demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor)
+CmiBool CkArray::demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor)
 {
        CkArrayMessage *m=(CkArrayMessage *)CkAllocSysMsg();
        prepareArrayCtorMsg(this,m,onPe,idx);
@@ -371,7 +371,7 @@ bool CkArray::demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor)
                return insertElement(m);
        else
                thisProxy[onPe].insertElement(m);
-       return true;
+       return CmiTrue;
 }
 
 void CkArray::insertInitial(const CkArrayIndex &idx,void *ctorMsg)
@@ -490,7 +490,7 @@ void CkArray::deliverBroadcast(CkArrayMessage *bcast)
 }
 
 //Deliver a copy of the given broadcast to the given local element
-bool CkArray::deliverBroadcast(CkArrayMessage *bcast,ArrayElement *el)
+CmiBool CkArray::deliverBroadcast(CkArrayMessage *bcast,ArrayElement *el)
 {
        el->bcastNo++;
        void *newMsg=CkCopyMsg((void **)&bcast);
@@ -499,7 +499,7 @@ bool CkArray::deliverBroadcast(CkArrayMessage *bcast,ArrayElement *el)
        return el->ckInvokeEntry(epIdx,newMsg);
 }
 //Deliver all needed broadcasts to the given local element
-bool CkArray::bringBroadcastUpToDate(ArrayElement *el)
+CmiBool CkArray::bringBroadcastUpToDate(ArrayElement *el)
 {
        if (el->bcastNo<bcastNo)
        {//This element needs some broadcasts-- it must have
@@ -516,11 +516,11 @@ bool CkArray::bringBroadcastUpToDate(ArrayElement *el)
                        oldBcasts.enq(msg);
                        if (!deliverBroadcast(msg,el)) 
                                //Element migrated away
-                               return false;
+                               return CmiFalse;
                }
        }
        //Otherwise, the element survived
-       return true;
+       return CmiTrue;
 }
 
 #include "CkArray.def.h"
index b8c2eb5d5953c60e6930415dedbffc4c26d1af78..20ece5544b25191653590bf042ab565b21cef66e 100644 (file)
@@ -334,10 +334,10 @@ public:
   void remoteDoneInserting(void);
 
   //Create manually:
-  virtual bool insertElement(CkMessage *);
+  virtual CmiBool insertElement(CkMessage *);
 
 //Demand-creation:
-  bool demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor);
+  CmiBool demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor);
 
 //Broadcast communication:
   void sendBroadcast(CkMessage *msg);
@@ -349,7 +349,7 @@ private:
 
 //Allocate space for a new array element
   ArrayElement *allocate(int elChareType,const CkArrayIndex &idx,
-       int bcast,bool fromMigration);
+       int bcast,CmiBool fromMigration);
   
 //Broadcast support
   int bcastNo;//Number of broadcasts received (also serial number)
@@ -357,9 +357,9 @@ private:
   //This queue stores old broadcasts (in case a migrant arrives
   // and needs to be brought up to date)
   CkQ<CkArrayMessage *> oldBcasts;
-  bool bringBroadcastUpToDate(ArrayElement *el);
+  CmiBool bringBroadcastUpToDate(ArrayElement *el);
   void deliverBroadcast(CkArrayMessage *bcast);
-  bool deliverBroadcast(CkArrayMessage *bcast,ArrayElement *el);
+  CmiBool deliverBroadcast(CkArrayMessage *bcast,ArrayElement *el);
 
 //Spring cleaning
   void springCleaning(void);
index 9a1eecfe313c37ff59592ab29d952b37743c06d2..414d1021c852eb52ca6065d5624ca38b5167d8b7 100644 (file)
@@ -502,10 +502,10 @@ Matches up the array index with the local index, and
 interfaces with the load balancer on behalf of the 
 represented array elements.
 */
-CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,bool fromMigration,
+CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
   const CkArrayIndex &idx_,int localIdx_) 
        :CkLocRec(mgr),idx(idx_),localIdx(localIdx_),
-        running(false),deletedMarker(NULL)
+        running(CmiFalse),deletedMarker(NULL)
 {
 #if CMK_LBDB_ON
        DEBL((AA"Registering element %s with load balancer\n"AB,idx2str(idx)));
@@ -520,7 +520,7 @@ CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,bool fromMigration,
 }
 CkLocRec_local::~CkLocRec_local()
 {
-       if (deletedMarker!=NULL) *deletedMarker=true;
+       if (deletedMarker!=NULL) *deletedMarker=CmiTrue;
        myLocMgr->reclaim(idx,localIdx);
 #if CMK_LBDB_ON
        stopTiming();
@@ -536,14 +536,14 @@ void CkLocRec_local::migrateMe(int toPe) //Leaving this processor
 
 #if CMK_LBDB_ON
 void CkLocRec_local::startTiming(void) {
-       running=true; 
+       running=CmiTrue; 
        DEBL((AA"Start timing for %s at %.3fs {\n"AB,idx2str(idx),CkWallTimer()));
        the_lbdb->ObjectStart(ldHandle);
 }
 void CkLocRec_local::stopTiming(void) {
        DEBL((AA"} Stop timing for %s at %.3fs\n"AB,idx2str(idx),CkWallTimer()));
        if (running) the_lbdb->ObjectStop(ldHandle);
-       running=false;
+       running=CmiFalse;
 }
 #endif
 
@@ -575,7 +575,7 @@ void CkLocRec_local::addedElement(void)
                myLocMgr->getLocalProxy().deliver(halfCreated.deq());
 }
 
-bool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
+CmiBool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
 { 
        int len=halfCreated.length();
        if (len!=0) {
@@ -587,12 +587,12 @@ bool CkLocRec_local::isObsolete(int nSprings,const CkArrayIndex &idx_)
                         len,idx2str(idx));
        }
        //A local element never expires
-       return false;
+       return CmiFalse;
 }
 
-bool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,int epIdx) {
+CmiBool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,int epIdx) {
        DEBS((AA"   Invoking entry %d on element %s\n"AB,epIdx,idx2str(idx)));
-       bool isDeleted=false; //Enables us to detect deletion during processing
+       CmiBool isDeleted=CmiFalse; //Enables us to detect deletion during processing
        deletedMarker=&isDeleted;
        //The currentChare globals are used by CkGetChareID()
        CkpvAccess(_currentChare) = (void*) obj;
@@ -605,17 +605,17 @@ bool CkLocRec_local::invokeEntry(CkMigratable *obj,void *msg,int epIdx) {
        }
        _entryTable[epIdx]->call(msg, obj);
        if (msg) _TRACE_END_EXECUTE();
-       if (isDeleted) return false;//We were deleted
+       if (isDeleted) return CmiFalse;//We were deleted
        deletedMarker=NULL;
        stopTiming();
-       return true;
+       return CmiTrue;
 }
 
-bool CkLocRec_local::deliver(CkArrayMessage *msg,bool viaScheduler)
+CmiBool CkLocRec_local::deliver(CkArrayMessage *msg,CmiBool viaScheduler)
 {
        if (viaScheduler) {
                myLocMgr->getLocalProxy().deliver(msg);
-               return true;
+               return CmiTrue;
        }
        else
        {
@@ -628,7 +628,7 @@ bool CkLocRec_local::deliver(CkArrayMessage *msg,bool viaScheduler)
                        else {
                                DEBS((AA"   BUFFERING message for nonexistent element %s!\n"AB,idx2str(this->idx)));
                                halfCreated.enq(msg);
-                               return true;
+                               return CmiTrue;
                        }
                }
                        
@@ -656,16 +656,16 @@ public:
   
        virtual RecType type(void) {return dead;}
   
-       virtual bool deliver(CkArrayMessage *msg,bool viaScheduler) {
+       virtual CmiBool deliver(CkArrayMessage *msg,CmiBool viaScheduler) {
                CkPrintf("Dead array element is %s.\n",idx2str(msg->array_index()));
                CkAbort("Send to dead array element!\n");
-               return false;
+               return CmiFalse;
        }
        virtual void beenReplaced(void) 
                {CkAbort("Can't re-use dead array element!\n");}
   
        //Return if this element is now obsolete (it isn't)
-       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx) {return CmiFalse;}        
+       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx) {return CmiFalse;}     
 };
 
 /*-------------------- aging
@@ -690,7 +690,7 @@ public:
                lastAccess=myLocMgr->getSpringCount();
        }
        //Return if this element is now obsolete
-       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx)=0;
+       virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx)=0;
        //virtual void pup(PUP::er &p) { CkLocRec::pup(p); p(lastAccess); }
 };
 
@@ -718,24 +718,24 @@ public:
        virtual RecType type(void) {return remote;}
   
        //Send a message for this element.
-       virtual bool deliver(CkArrayMessage *msg,bool viaScheduler) {
+       virtual CmiBool deliver(CkArrayMessage *msg,CmiBool viaScheduler) {
                access();//Update our modification date
                msg->array_hops()++;
                DEBS((AA"   Forwarding message for element %s to %d (REMOTE)\n"AB,
                      idx2str(msg->array_index()),onPe));
                myLocMgr->getProxy()[onPe].deliver(msg);
-               return true;
+               return CmiTrue;
        }
        //Return if this element is now obsolete
-       virtual bool isObsolete(int nSprings,const CkArrayIndex &idx) {
+       virtual CmiBool 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 false;
+                       return CmiFalse;
                else if (isStale())
-                       return true;//We haven't been used in a long time
+                       return CmiTrue;//We haven't been used in a long time
                else
-                       return false;//We're fairly recent
+                       return CmiFalse;//We're fairly recent
        }
        //virtual void pup(PUP::er &p) { CkLocRec_aging::pup(p); p(onPe); }
 };
@@ -762,10 +762,10 @@ public:
        //Send (or buffer) a message for this element.
        //  If idx==NULL, the index is packed in the message.
        //  If idx!=NULL, the index must be packed in the message.
-       virtual bool deliver(CkArrayMessage *msg,bool viaScheduler) {
+       virtual CmiBool deliver(CkArrayMessage *msg,CmiBool viaScheduler) {
                DEBS((AA" Queued message for %s\n"AB,idx2str(msg->array_index())));
                buffer.enq(msg);
-               return true;
+               return CmiTrue;
        }
   
        //This is called when this ArrayRec is about to be replaced.
@@ -851,7 +851,7 @@ CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,int numInitial)
        nManagers=0;
        firstManager=NULL;
        firstFree=localLen=0;
-       duringMigration=false;
+       duringMigration=CmiFalse;
        nSprings=0;
        CcdCallOnConditionKeepOnPE(CcdPERIODIC_1minute,staticSpringCleaning,(void *)this, CkMyPe());
 
@@ -933,7 +933,7 @@ void CkLocMgr::informHome(const CkArrayIndex &idx,int nowOnPe)
 }
 
 //Add a new local array element, calling element's constructor
-bool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
+CmiBool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
                CkMigratable *elt,int ctorIdx,void *ctorMsg)
 {
        magic.check();
@@ -943,7 +943,7 @@ bool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
        { //This is the first we've heard of that element-- add new local record
                int localIdx=nextFree();
                DEBC((AA"Adding new record for element %s at local index %d\n"AB,idx2str(idx),localIdx));
-               rec=new CkLocRec_local(this,false,idx,localIdx);
+               rec=new CkLocRec_local(this,CmiFalse,idx,localIdx);
                insertRec(rec,idx); //Add to global hashtable
                informHome(idx,CkMyPe());
        } else 
@@ -951,13 +951,13 @@ bool CkLocMgr::addElement(CkArrayID id,const CkArrayIndex &idx,
                rec=((CkLocRec_local *)oldRec);
                rec->addedElement();
        }
-       if (!addElementToRec(rec,&managers.find(id),elt,ctorIdx,ctorMsg)) return false;
+       if (!addElementToRec(rec,&managers.find(id),elt,ctorIdx,ctorMsg)) return CmiFalse;
        elt->ckFinishConstruction();
-       return true;
+       return CmiTrue;
 }
 
 //As above, but shared with the migration code
-bool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
+CmiBool 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();
@@ -970,9 +970,9 @@ bool 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)) return false;
+       if (!rec->invokeEntry(elt,ctorMsg,ctorIdx)) return CmiFalse;
        
-       return true;
+       return CmiTrue;
 }
 void CkLocMgr::updateLocation(const CkArrayIndexMax &idx,int nowOnPe) {
        inform(idx,nowOnPe);
@@ -1021,23 +1021,23 @@ void CkLocMgr::deliverViaQueue(CkMessage *m) {
 #endif
        CkLocRec *rec=elementNrec(idx);
        if (rec!=NULL)
-               rec->deliver(msg,true);
+               rec->deliver(msg,CmiTrue);
        else deliverUnknown(msg);
 }
 //Deliver message directly to this element
-bool CkLocMgr::deliver(CkMessage *m) {
+CmiBool CkLocMgr::deliver(CkMessage *m) {
        magic.check();
        CkArrayMessage *msg=(CkArrayMessage *)m;
        const CkArrayIndex &idx=msg->array_index();
        DEBS((AA"deliver %s\n"AB,idx2str(idx)));
        CkLocRec *rec=elementNrec(idx);
        if (rec!=NULL)
-               return rec->deliver(msg,false);
+               return rec->deliver(msg,CmiFalse);
        else 
                return deliverUnknown(msg);
 }
 
-bool CkLocMgr::deliverUnknown(CkArrayMessage *msg)
+CmiBool CkLocMgr::deliverUnknown(CkArrayMessage *msg)
 {//This index is not hashed-- send to its home processor
        magic.check();
        const CkArrayIndex &idx=msg->array_index();
@@ -1046,7 +1046,7 @@ bool CkLocMgr::deliverUnknown(CkArrayMessage *msg)
                DEBM((AA"Forwarding message for unknown %s\n"AB,idx2str(idx)));
                msg->array_hops()++;
                thisProxy[onPe].deliver(msg);
-               return true;
+               return CmiTrue;
        }
        else
        {// We *are* the home processor-- decide what to do
@@ -1056,14 +1056,14 @@ bool CkLocMgr::deliverUnknown(CkArrayMessage *msg)
                DEBC((AA"Adding buffer for unknown element %s\n"AB,idx2str(idx)));
                CkLocRec *rec=new CkLocRec_buffering(this);
                insertRecN(rec,idx);
-               return rec->deliver(msg,true);         
+               return rec->deliver(msg,CmiTrue);              
          }
          else 
                return demandCreateElement(msg,-1);
        }
 }
 
-bool CkLocMgr::demandCreateElement(CkArrayMessage *msg,int onPe)
+CmiBool CkLocMgr::demandCreateElement(CkArrayMessage *msg,int onPe)
 {
        magic.check();
        const CkArrayIndex &idx=msg->array_index();
@@ -1082,7 +1082,7 @@ bool CkLocMgr::demandCreateElement(CkArrayMessage *msg,int onPe)
        //Find the manager and build the element
        DEBC((AA"Demand-creating element %s on pe %d\n"AB,idx2str(idx),onPe));
        CkArrMgr *mgr=managers.find(UsrToEnv((void *)msg)->array_mgr()).mgr;
-       bool created=mgr->demandCreateElement(idx,onPe,ctor);
+       CmiBool created=mgr->demandCreateElement(idx,onPe,ctor);
 
        //Try the delivery again-- it should succeed this time
        deliver(msg);
@@ -1190,9 +1190,9 @@ void CkLocMgr::migrate(CkLocRec_local *rec,int toPe)
 
 //Send off message and delete old copy
        thisProxy[toPe].migrateIncoming(msg);
-       duringMigration=true;
+       duringMigration=CmiTrue;
        delete rec; //Removes elements, hashtable entries, local index
-       duringMigration=false;
+       duringMigration=CmiFalse;
        //The element now lives on another processor-- tell ourselves and its home
        inform(idx,toPe);
        informHome(idx,toPe);
@@ -1217,7 +1217,7 @@ void CkLocMgr::migrateIncoming(CkArrayElementMigrateMessage *msg)
 
        //Create a record for this element
        int localIdx=nextFree();
-       CkLocRec_local *rec=new CkLocRec_local(this,true,idx,localIdx);
+       CkLocRec_local *rec=new CkLocRec_local(this,CmiTrue,idx,localIdx);
        insertRec(rec,idx); //Add to global hashtable
        
        //Create the new elements as we unpack the message
index 88c748928e3a85c70b745a6f8240246836e5d92a..29b39eb8dd5ec120453778df473ba947ff6699f3 100644 (file)
@@ -200,14 +200,14 @@ public:
   virtual RecType type(void)=0;
   
   //Accept a message for this element
-  virtual bool deliver(CkArrayMessage *m,bool viaScheduler)=0;
+  virtual CmiBool deliver(CkArrayMessage *m,CmiBool viaScheduler)=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 bool isObsolete(int nSprings,const CkArrayIndex &idx)=0; 
+  virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx)=0; 
 
   //Return the represented array element; or NULL if there is none
   virtual CkMigratable *lookupElement(CkArrayID aid);
@@ -218,12 +218,12 @@ public:
 class CkLocRec_local : public CkLocRec {
   CkArrayIndexMax idx;//Array index
   int localIdx; //Local index
-  bool running; //Inside a startTiming/stopTiming pair
-  bool *deletedMarker; //Set this if we're deleted during processing
+  CmiBool running; //Inside a startTiming/stopTiming pair
+  CmiBool *deletedMarker; //Set this if we're deleted during processing
   CkQ<CkArrayMessage *> halfCreated; //Messages for nonexistent siblings of existing elements
 public:
   //Creation and Destruction:
-  CkLocRec_local(CkLocMgr *mgr,bool fromMigration,
+  CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
        const CkArrayIndex &idx_,int localIdx_);
   void migrateMe(int toPe); //Leave this processor
   void destroy(void); //User called destructor
@@ -234,14 +234,14 @@ public:
 
   //Accept a message for this element
   // Returns false if the element died in transit
-  virtual bool deliver(CkArrayMessage *m,bool viaScheduler);
+  virtual CmiBool deliver(CkArrayMessage *m,CmiBool viaScheduler);
   
   //Invoke the given entry method on this element
   // Returns false if the element died in transit
-  bool invokeEntry(CkMigratable *obj,void *msg,int idx);
+  CmiBool invokeEntry(CkMigratable *obj,void *msg,int idx);
 
   virtual RecType type(void);
-  virtual bool isObsolete(int nSprings,const CkArrayIndex &idx);
+  virtual CmiBool isObsolete(int nSprings,const CkArrayIndex &idx);
   
 #if CMK_LBDB_ON  //For load balancing:
   //Load balancer
@@ -306,7 +306,7 @@ public:
 
   //Execute the given entry method.  Returns false if the element 
   // deleted itself or migrated away during execution.
-  inline bool ckInvokeEntry(int epIdx,void *msg) 
+  inline CmiBool ckInvokeEntry(int epIdx,void *msg) 
          {return myRec->invokeEntry(this,msg,epIdx);}
 
 protected:
@@ -408,7 +408,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 bool demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor) =0;
+       virtual CmiBool demandCreateElement(const CkArrayIndex &idx,int onPe,int ctor) =0;
 };
 
 //A group which manages the location of an indexed set of
@@ -437,7 +437,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.
-       bool addElement(CkArrayID aid,const CkArrayIndex &idx,
+       CmiBool addElement(CkArrayID aid,const CkArrayIndex &idx,
                CkMigratable *elt,int ctorIdx,void *ctorMsg);
        
        //Deliver message to this element, going via the scheduler if local
@@ -479,21 +479,21 @@ public:
 
        int getSpringCount(void) const { return nSprings; }
 
-       bool demandCreateElement(CkArrayMessage *msg,int onPe);
+       CmiBool demandCreateElement(CkArrayMessage *msg,int onPe);
        
 //Interface used by external users:
        //Home mapping
        inline int homePe(const CkArrayIndex &idx) const
                {return map->procNum(mapHandle,idx);}   
-       inline bool isHome(const CkArrayIndex &idx) const
-               {return homePe(idx)==CkMyPe();}
+       inline CmiBool isHome(const CkArrayIndex &idx) const
+               {return (CmiBool)(homePe(idx)==CkMyPe());}
        //Look up the object with this array index, or return NULL
        CkMigratable *lookup(const CkArrayIndex &idx,CkArrayID aid);
        //"Last-known" location (returns a processor number)
        int lastKnown(const CkArrayIndex &idx) const;
 
 //Communication:
-       bool deliver(CkMessage *m);
+       CmiBool deliver(CkMessage *m);
        void migrateIncoming(CkArrayElementMigrateMessage *msg);
        void updateLocation(const CkArrayIndexMax &idx,int nowOnPe);
        void reclaimRemote(const CkArrayIndexMax &idx,int deletedOnPe);
@@ -514,7 +514,7 @@ private:
        CkLocRec *elementNrec(const CkArrayIndex &idx);
 
        void pupElementsFor(PUP::er &p,CkLocRec_local *rec);
-       bool deliverUnknown(CkArrayMessage *msg);
+       CmiBool deliverUnknown(CkArrayMessage *msg);
 
 //Data Members:
        //Map array ID to manager and elements
@@ -536,7 +536,7 @@ private:
        int nManagers;
        ManagerRec *firstManager; //First non-null array manager
 
-       bool addElementToRec(CkLocRec_local *rec,ManagerRec *m,
+       CmiBool addElementToRec(CkLocRec_local *rec,ManagerRec *m,
                CkMigratable *elt,int ctorIdx,void *ctorMsg);
        
        //For keeping track of free local indices
@@ -550,7 +550,7 @@ private:
        CkHashtableT<CkArrayIndexMax,CkLocRec *> hash;
        
        //This flag is set while we delete an old copy of a migrator
-       bool duringMigration;
+       CmiBool duringMigration;
        
        //Occasionally clear out stale remote pointers
        static void staticSpringCleaning(void *mgr);