support for medium resilience
authorXiang Ni <xiangni2@illinois.edu>
Tue, 18 Dec 2012 03:53:32 +0000 (21:53 -0600)
committerXiang Ni <xiangni2@illinois.edu>
Tue, 18 Dec 2012 03:53:32 +0000 (21:53 -0600)
src/ck-core/cklocation.C
src/ck-core/cklocation.h
src/ck-core/ckmemcheckpoint.C
src/ck-core/ckmemcheckpoint.ci
src/ck-core/ckmemcheckpoint.h
src/ck-ldb/LBDBManager.C
src/ck-ldb/LBDBManager.h
src/ck-ldb/LBDatabase.h
src/util/pup.h
src/util/pup_stl.h

index c8c1f2362bffe67674df67b1afb64a0167efbe2f..c9f5f1b112456805a6994d81cb0bd02e6077a077 100644 (file)
@@ -1098,6 +1098,12 @@ void CkMigratable::pup(PUP::er &p) {
        p | asyncEvacuate;
        if(p.isUnpacking()){myRec->AsyncEvacuate(asyncEvacuate);}
        
+       p | chkp_cb;
+       p | atsync_chkp_iter;   
+       if(p.isUnpacking()){
+               resetForChkp();
+       }
+
        ckFinishConstruction();
 }
 
@@ -1128,7 +1134,7 @@ CkMigratable::~CkMigratable() {
 #if CMK_LBDB_ON 
        if (barrierRegistered) {
          DEBL((AA"Removing barrier for element %s\n"AB,idx2str(thisIndexMax)));
-         CkPrintf("Removing barrier for element %s\n",idx2str(thisIndexMax));
+         //CkPrintf("Removing barrier for element %s\n",idx2str(thisIndexMax));
          if (usesAtSync)
                myRec->getLBDB()->RemoveLocalBarrierClient(ldBarrierHandle);
          else
@@ -1211,7 +1217,7 @@ void CkMigratable::ckFinishConstruction(void)
        myRec->setMeasure(usesAutoMeasure);
        if (barrierRegistered) return;
        DEBL((AA"Registering barrier client for %s\n"AB,idx2str(thisIndexMax)));
-       CkPrintf("Registering barrier client for %s\n",idx2str(thisIndexMax));
+       //CkPrintf("Registering barrier client for %s\n",idx2str(thisIndexMax));
         if (usesAtSync)
          ldBarrierHandle = myRec->getLBDB()->AddLocalBarrierClient(
                (LDBarrierFn)staticResumeFromSync,(void*)(this));
@@ -1221,6 +1227,78 @@ void CkMigratable::ckFinishConstruction(void)
        barrierRegistered=CmiTrue;
 }
 
+
+void CkMigratable::setChkpResumeClient(CkCallback & _cb)
+{
+       chkp_cb = _cb;
+       nextChkpIter = -1;
+       nextChkpDecided = false;
+       atsync_chkp_iter = -1;
+       local_chkp_pause = false;
+}
+
+void CkMigratable::AtChkpSync()
+{
+       if(CmiNumPartition()==1){
+               chkp_cb.send();
+               return;
+       }
+       atsync_chkp_iter++;
+       myRec->getChkpMgr()->recvIter(atsync_chkp_iter);
+       //reduction to decide the current maximum
+       if(nextChkpDecided){
+               if(atsync_chkp_iter<nextChkpIter){
+                       chkp_cb.send();
+               }else if(atsync_chkp_iter == nextChkpIter){
+                       resetForChkp();
+                       myRec->getChkpMgr()->reachChkpIter();
+               }else{
+                       CkAbort("Impossible state\n");
+               }
+       }
+       else if(myRec->getChkpMgr()->localDecided){
+               int localIter = myRec->getChkpMgr()->localMaxIter;
+               if(atsync_chkp_iter==localIter){
+                       local_chkp_pause = true;
+               }
+               else if(atsync_chkp_iter<localIter){
+                       chkp_cb.send();
+               }
+               else{
+                       CkAbort("local Impossible state\n");
+               }
+       }       
+       else{
+               chkp_cb.send();
+       }
+}
+
+void CkMigratable::resetForChkp(){
+       nextChkpDecided = false;
+       local_chkp_pause = false;
+}
+
+void CkMigratable::ResumeFromChkp(){
+       chkp_cb.send();
+}
+
+void CkMigratable::recvChkpIter(void * _iter){
+       int iter = *(int *)_iter;
+       nextChkpIter = iter;
+       nextChkpDecided = true;
+       if(atsync_chkp_iter>nextChkpIter){
+               CkAbort("impossible state in notify\n");
+       }
+       else if(atsync_chkp_iter==nextChkpIter){
+               resetForChkp();
+               myRec->getChkpMgr()->reachChkpIter();
+       }
+       else{
+               if(local_chkp_pause)
+                       chkp_cb.send(); 
+       }
+}
+
 void CkMigratable::AtSync(int waitForMigration)
 {
        if (!usesAtSync)
@@ -1233,7 +1311,7 @@ void CkMigratable::AtSync(int waitForMigration)
        ckFinishConstruction();
   //DEBL((AA"Element %s going to sync\n"AB,idx2str(thisIndexMax)));
   //if(CmiMyPartition()==1)
-       CkPrintf("Element %s going to sync\n",idx2str(thisIndexMax));
+//     CkPrintf("Element %s going to sync\n",idx2str(thisIndexMax));
   // model-based load balancing, ask user to provide cpu load
   if (usesAutoMeasure == CmiFalse) UserSetLBLoad();
 
@@ -1421,6 +1499,7 @@ CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
        bounced  = CmiFalse;
        the_lbdb=mgr->getLBDB();
        the_metalb=mgr->getMetaBalancer();
+       the_chkp = mgr->getChkpMgr();
        LDObjid ldid = idx2LDObjid(idx);
 #if CMK_GLOBAL_LOCATION_UPDATE
         ldid.locMgrGid = mgr->getGroupID().idx;
@@ -1436,6 +1515,7 @@ CkLocRec_local::CkLocRec_local(CkLocMgr *mgr,CmiBool fromMigration,
                }
        }
 #endif
+       the_chkp = mgr->getChkpMgr();
        /*
                FAULT_EVAC
        */
@@ -2017,6 +2097,39 @@ void CkLocMgr::flushLocalRecs(void)
   CmiImmediateUnlock(hashImmLock);
 }
 
+void CkLocMgr::recvChkpIter(int iter)
+{
+  void *objp;
+  void *keyp;
+  CkHashtableIterator *it=hash.iterator();
+  CmiImmediateLock(hashImmLock);
+  while (NULL!=(objp=it->next(&keyp))) {
+    CkLocRec *rec=*(CkLocRec **)objp;
+    CkArrayIndex &idx=*(CkArrayIndex *)keyp;
+    if (rec->type() == CkLocRec::local) {
+        callMethod((CkLocRec_local*)rec, &CkMigratable::recvChkpIter,&iter);
+    }
+  }
+  delete it;
+  CmiImmediateUnlock(hashImmLock);
+}
+
+void CkLocMgr::resumeFromChkp(){
+  void *objp;
+  void *keyp;
+  CkHashtableIterator *it=hash.iterator();
+  CmiImmediateLock(hashImmLock);
+  while (NULL!=(objp=it->next(&keyp))) {
+    CkLocRec *rec=*(CkLocRec **)objp;
+    CkArrayIndex &idx=*(CkArrayIndex *)keyp;
+    if (rec->type() == CkLocRec::local) {
+        callMethod((CkLocRec_local*)rec, &CkMigratable::ResumeFromChkp);
+    }
+  }
+  delete it;
+  CmiImmediateUnlock(hashImmLock);
+}
+
 // clean all buffer'ed messages and also free local objects
 void CkLocMgr::flushAllRecs(void)
 {
@@ -2095,6 +2208,8 @@ CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkGroupID metalbID_,CkArra
   metalbID = metalbID_;
        initLB(lbdbID_, metalbID_);
        hashImmLock = CmiCreateImmediateLock();
+       chkpID = ckCheckPTGroupID;
+       the_chkp = (CkMemCheckPT *)CkLocalBranch(chkpID);
 }
 
 CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkArrayIndex& numInitial)
@@ -2129,6 +2244,7 @@ void CkLocMgr::pup(PUP::er &p){
        p|mapHandle;
        p|lbdbID;
   p|metalbID;
+   p|chkpID;
        mapID = _defaultArrayMapID;
        if(p.isUnpacking()){
                thisProxy=thisgroup;
@@ -2141,6 +2257,7 @@ void CkLocMgr::pup(PUP::er &p){
                map->registerArray(emptyIndex,thisgroup);
                // _lbdb is the fixed global groupID
                initLB(lbdbID, metalbID);
+               the_chkp = (CkMemCheckPT *)CkLocalBranch(chkpID);
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_)) ||CMK_MEM_CHECKPOINT    
         int count;
         p | count;
@@ -2831,7 +2948,6 @@ void CkLocMgr::pupElementsFor(PUP::er &p,CkLocRec_local *rec,
                  if (c) c->redNo = 0;
                }
          }
-               
        }
 #endif
 }
index 43baba7fe0d8ee86fc9bf65b2d0902856ac0b6ba..936ef59f6b651e11d665ed9240edd9b18ef36c09 100644 (file)
@@ -212,7 +212,7 @@ public:
   inline const CkArrayIndex &getIndex(void) const {return idx;}
   virtual CkMigratable *lookupElement(CkArrayID aid);
   virtual int lookupProcessor(void);
-
+  inline CkMemCheckPT *getChkpMgr(void) const {return the_chkp;} 
 #if CMK_LBDB_ON
 public:
   inline LBDatabase *getLBDB(void) const {return the_lbdb;}
@@ -238,6 +238,7 @@ public:
 private:
   LBDatabase *the_lbdb;
   MetaBalancer *the_metalb;
+  CkMemCheckPT * the_chkp;
   LDObjHandle ldHandle;
   CmiBool  asyncMigrate;  /// if readyMove is inited
   CmiBool  readyMigrate;    /// status whether it is ready to migrate
@@ -281,6 +282,9 @@ private:
   void commonInit(void);
   CmiBool asyncEvacuate;
   int atsync_iteration;
+  int atsync_chkp_iter;
+  int nextChkpIter; 
+  CkCallback chkp_cb;
 
   enum state {
     OFF,
@@ -289,6 +293,9 @@ private:
     DECIDED,
     LOAD_BALANCE
   } local_state;
+  
+  bool local_chkp_pause;
+  bool nextChkpDecided;
   double  prev_load;
   bool can_reset;
 
@@ -357,6 +364,7 @@ public:
   double getObjTime();
 
 #if CMK_LBDB_ON  //For load balancing:
+  
   void AtSync(int waitForMigration=1);
   int MigrateToPe()  { return myRec->MigrateToPe(); }
 
@@ -375,6 +383,12 @@ public:
   void ckFinishConstruction(void) { }
 #endif
 
+  void AtChkpSync();
+  void resetForChkp();
+  void recvChkpIter(void * _iter);
+  void ResumeFromChkp();
+
+  void setChkpResumeClient(CkCallback &cb);
 #if CMK_OUT_OF_CORE
 private:
   friend class CkLocMgr;
@@ -609,7 +623,7 @@ public:
        void emigrate(CkLocRec_local *rec,int toPe);
   void informLBPeriod(CkLocRec_local *rec, int lb_ideal_period);
   void metaLBCallLB(CkLocRec_local *rec);
-
+  CkMemCheckPT * getChkpMgr(void) const{return the_chkp;}
 #if CMK_LBDB_ON
        LBDatabase *getLBDB(void) const { return the_lbdb; }
   MetaBalancer *getMetaBalancer(void) const { return the_metalb;}
@@ -669,6 +683,8 @@ public:
 
        void flushAllRecs(void);
        void flushLocalRecs(void);
+       void recvChkpIter(int iter);
+       void resumeFromChkp();
        void pup(PUP::er &p);
        
        //Look up array element in hash table.  Index out-of-bounds if not found.
@@ -771,6 +787,9 @@ public:
 
        CkGroupID lbdbID;
        CkGroupID metalbID;
+       CkGroupID chkpID;
+
+       CkMemCheckPT * the_chkp;
 #if CMK_LBDB_ON
        LBDatabase *the_lbdb;
   MetaBalancer *the_metalb;
index 35482d4d0b3c04728add73e5f0c6880c70209994..5b4a1b24c1f6886b9e48d298710e4de105eb8b2f 100644 (file)
@@ -378,6 +378,9 @@ CkMemCheckPT::CkMemCheckPT(int w)
 #endif
   chkpTable[0] = NULL;
   chkpTable[1] = NULL;
+  maxIter = -1;
+  recvIterCount = 0;
+  localDecided = false;
 }
 
 CkMemCheckPT::~CkMemCheckPT()
@@ -406,9 +409,44 @@ void CkMemCheckPT::pup(PUP::er& p)
     CcdCallOnCondition(CcdPERIODIC_100ms,(CcdVoidFn)pingBuddy,NULL);
     CcdCallOnCondition(CcdPERIODIC_1s,(CcdVoidFn)pingCheckHandler,NULL);
 #endif
+         maxIter = -1;
+         recvIterCount = 0;
+         localDecided = false;
   }
 }
 
+void CkMemCheckPT::getIter(){
+       localDecided = true;
+       localMaxIter = maxIter+1;
+       contribute(sizeof(int),&localMaxIter,CkReduction::max_int,CkCallback(CkReductionTarget(CkMemCheckPT,recvMaxIter),thisProxy));
+}
+
+//when one replica failes, decide the next chkp iter
+
+void CkMemCheckPT::recvIter(int iter){
+       if(maxIter<iter){
+               maxIter=iter;
+       }
+}
+
+void CkMemCheckPT::recvMaxIter(int iter){
+       localDecided = false;
+       CKLOCMGR_LOOP(mgr->recvChkpIter(iter););
+}
+
+void CkMemCheckPT::reachChkpIter(){
+       recvIterCount++;
+       elemCount = CkCountArrayElements();
+       if(recvIterCount == elemCount){
+               recvIterCount = 0;
+               contribute(CkCallback(CkReductionTarget(CkMemCheckPT,startChkp),thisProxy[0]));
+       }
+}
+
+void CkMemCheckPT::startChkp(){
+       CkStartMemCheckpoint(cpCallback);
+}
+
 // called by checkpoint mgr to restore an array element
 void CkMemCheckPT::inmem_restore(CkArrayCheckPTMessage *m) 
 {
@@ -721,9 +759,10 @@ void CkMemCheckPT::doneRComparison(int ret){
        CpvAccess(curPointer)^=1;
                if(CkMyPe() == 0){
                CkPrintf("[%d][%d] Checkpoint finished in %f seconds, sending callback ... \n", CmiMyPartition(),CkMyPe(), CmiWallTimer()-startTime);
-                       cpCallback.send();
                }
-       }else{
+               CKLOCMGR_LOOP(mgr->resumeFromChkp(););
+       }
+       else{
        CkPrintf("[%d][%d] going to RollBack \n", CmiMyPartition(),CkMyPe());
                RollBack();
        }
@@ -736,7 +775,6 @@ void CkMemCheckPT::RollBack(){
        int pointer = CpvAccess(curPointer)^1;//use the previous one
     CkCheckPTMessage* chkpMsg = CpvAccess(chkpBuf)[pointer];
        PUP::fromMem p(chkpMsg->packData);      
-       //_handleProcData(p);
        
        //destroy array elements
        CKLOCMGR_LOOP(mgr->flushLocalRecs(););
@@ -769,7 +807,7 @@ void CkMemCheckPT::RollBack(){
 }
 
 void CkMemCheckPT::notifyReplicaDie(int pe){
-       CkPrintf("[%d] receive replica die\n",CkMyPe());
+       //CkPrintf("[%d] receive replica die\n",CkMyPe());
        replicaAlive = 0;
        CpvAccess(_remoteCrashedNode) = pe;
 }
@@ -907,7 +945,6 @@ void CkMemCheckPT::cpFinish()
   if (peCount == 2) 
 {
     CmiPrintf("[%d] Checkpoint finished in %f seconds, sending callback ... \n", CkMyPe(), CmiWallTimer()-startTime);
-    cpCallback.send();
     peCount = 0;
     thisProxy.report();
   }
@@ -916,6 +953,7 @@ void CkMemCheckPT::cpFinish()
 // for debugging, report checkpoint info
 void CkMemCheckPT::report()
 {
+       CKLOCMGR_LOOP(mgr->resumeFromChkp(););
        inCheckpointing = 0;
 #if !CMK_CHKP_ALL
   int objsize = 0;
@@ -1344,9 +1382,9 @@ void CkMemCheckPT::finishUp()
   if (CkMyPe() == thisFailedPe)
   {
        CkPrintf("[%d] CkMemCheckPT ----- %s in %f seconds, callback triggered\n",CkMyPe(), stage, CmiWallTimer()-startTime);
-       cpCallback.send();
        CkPrintf("[%d] Restart finished in %f seconds at %f.\n", CkMyPe(), CkWallTimer()-restartT, CkWallTimer());
   }
+  CKLOCMGR_LOOP(mgr->resumeFromChkp(););
        
 #if CMK_CONVERSE_MPI   
   if(CmiNumPartition()!=1){
@@ -1379,8 +1417,7 @@ void CkMemCheckPT::finishUp()
 void CkMemCheckPT::recoverFromSoftFailure()
 {
        inRestarting = 0;
-       if(CkMyPe()==0)
-       cpCallback.send();
+       CKLOCMGR_LOOP(mgr->resumeFromChkp(););
 }
 // called only on 0
 void CkMemCheckPT::quiescence(CkCallback &cb)
@@ -1526,7 +1563,7 @@ bool compare(char * buf1, char *buf2){
        
        int numElements;
        pchecker|numElements;
-       CkPrintf("[%d][%d]numElements:%d\n",CmiMyPartition(),CkMyPe(),numElements);
+//     CkPrintf("[%d][%d]numElements:%d\n",CmiMyPartition(),CkMyPe(),numElements);
        for(int i=0;i<numElements;i++){
        //for(int i=0;i<1;i++){
                CkGroupID gID;
@@ -1535,10 +1572,10 @@ bool compare(char * buf1, char *buf2){
                pchecker|gID;
                pchecker|idx;
                
-               CkPrintf("[%d][%d]resume\n",CmiMyPartition(),CkMyPe());
+//             CkPrintf("[%d][%d]resume\n",CmiMyPartition(),CkMyPe());
                CkLocMgr * mgr = (CkLocMgr *)CkpvAccess(_groupTable)->find(gID).getObj();
                mgr->resume(idx,pchecker,CmiFalse,CmiFalse,CmiFalse);
-               CkPrintf("------[%d][%d]finish element %d\n",CmiMyPartition(),CkMyPe(),i);
+//             CkPrintf("------[%d][%d]finish element %d\n",CmiMyPartition(),CkMyPe(),i);
        }
        if(pchecker.getResult()){
                CkPrintf("------[%d][%d]pass result\n",CmiMyPartition(),CkMyPe());
@@ -1589,9 +1626,11 @@ static void replicaDieHandler(char * msg){
            CkPrintf("replicaAlive %d\n",CkMemCheckPT::replicaAlive);
     }
 #endif
-       //broadcast to my partition
-       //CProxy_CkMemCheckPT checkptMgr(ckCheckPTGroupID);
-       //checkptMgr.notifyReplicaDie(diePe);
+       //broadcast to my partition to get local max iter
+    if(CkMyPe()==diePe){
+               CProxy_CkMemCheckPT checkptMgr(ckCheckPTGroupID);
+               checkptMgr.getIter();
+       }
     //CmiSetHandler(msg, replicaDieBcastHandlerIdx);
     //CmiSyncBroadcastAllAndFree(CmiMsgHeaderSizeBytes+sizeof(int), (char *)msg);
 }
@@ -1825,8 +1864,8 @@ int CkInRestarting()
 extern "C"
 int CkReplicaAlive()
 {
-       if(CkMyPe() == CpvAccess(_remoteCrashedNode))
-         CkPrintf("replicaAlive %d\n",CkMemCheckPT::replicaAlive);
+//     if(CkMyPe() == CpvAccess(_remoteCrashedNode))
+//       CkPrintf("replicaAlive %d\n",CkMemCheckPT::replicaAlive);
        return CkMemCheckPT::replicaAlive;
 
        /*if(CkMemCheckPT::replicaDead==1)
index ada66a74c6fdc7f165823e7fc86f83009564045b..2458de71275d281bc36729814295bcae937e0086 100644 (file)
@@ -37,6 +37,14 @@ module CkMemCheckpoint {
        entry [reductiontarget] void finishUp();
        entry [reductiontarget] void doneRComparison(int);
        entry [reductiontarget] void recoverFromSoftFailure();
+       
+       entry [reductiontarget] void recvMaxIter(int iter);
+       entry [reductiontarget] void startChkp();
+       entry void recvIter(int iter);
+
+       entry void getIter();
+       entry void reachChkpIter();
+       
        entry void notifyReplicaDie(int pe);
        entry void doneComparison(bool);
        entry void RollBack();
index 0bdc4e38b6fcd68970e4442d5f03e2427815bb84..fd5b73f0c390d058d41a819f9da5cc7d0f284697 100644 (file)
@@ -101,6 +101,13 @@ public:
   void RollBack();
   void recoverFromSoftFailure();
   void notifyReplicaDie(int diePe);
+
+  void recvIter(int);
+  void getIter();
+  void recvMaxIter(int);
+  void reachChkpIter();
+  void startChkp();
+
 public:
   static CkCallback  cpCallback;
 
@@ -110,6 +117,10 @@ public:
   static int replicaAlive;
   static double startTime;
   static char*  stage;
+  
+  bool inProgress;
+  bool localDecided;
+  int localMaxIter;
 private:
   CkVec<CkCheckPTInfo *> ckTable;
   CkArrayCheckPTMessage * chkpTable[2];
@@ -121,6 +132,11 @@ private:
   CkVec<int> failedPes;
   int thisFailedPe;
 
+  int elemCount;
+
+  int recvIterCount;
+
+  int maxIter;
     /// to use memory or disk checkpointing
   int    where;
 private:
index ba65a5ddf70bfa911aa969ce096a3bfb7ee1105e..3dc6a82c27c42694a7ebcff17c6c755290a6187f 100644 (file)
@@ -619,7 +619,7 @@ void LocalBarrier::AtBarrier(LDBarrierClient h)
   (clients[h.serial])->refcount++;
   at_count++;
   //if(CmiMyPartition()==1)
- CkPrintf("[%d][%d] at barrier\n",CmiMyPartition(),CkMyPe());
//CkPrintf("[%d][%d] at barrier\n",CmiMyPartition(),CkMyPe());
   CheckBarrier();
 }
 
@@ -630,7 +630,7 @@ void LocalBarrier::CheckBarrier()
   // If there are no clients, resume as soon as we're turned on
 
   //if(CmiMyPartition()==1){
      CkPrintf("[%d] at_count %d client_count %d\n",CkMyPe(),at_count,client_count);
//    CkPrintf("[%d] at_count %d client_count %d\n",CkMyPe(),at_count,client_count);
   //}
   if (client_count == 0) {
     cur_refcount++;
index 255761b93ead440807596d31fba5090d4d95a1b1..e815e965c8ea9e55cc44bd78cff5914fbc06ac0c 100644 (file)
@@ -202,7 +202,7 @@ public:
        { localBarrier.TurnOffReceiver(h); };
   inline void AtLocalBarrier(LDBarrierClient h) 
        { 
-                       CkPrintf("[%d][%d] LBDBManager local barrier\n",CmiMyPartition(),CkMyPe());
+                       //CkPrintf("[%d][%d] LBDBManager local barrier\n",CmiMyPartition(),CkMyPe());
                   if (useBarrier) 
                   localBarrier.AtBarrier(h); 
           };
index 1b7fad3318123706af1e7cfff7aa910c4927933d..f20a66f556d71a123838933f388a287602abc26e 100644 (file)
@@ -348,7 +348,7 @@ public:
   };
 
   inline void AtLocalBarrier(LDBarrierClient h) {
-    CkPrintf("[%d][%d]local barrier\n",CmiMyPartition(),CkMyPe());
+    //CkPrintf("[%d][%d]local barrier\n",CmiMyPartition(),CkMyPe());
          LDAtLocalBarrier(myLDHandle,h);
   }
   inline void LocalBarrierOn(void) { LDLocalBarrierOn(myLDHandle); };
index 1a16fb7f366e2d3cbe887fbe020c76e3017b80b9..26e5be26a5469a8a2b81300d773af28289ee52ed 100644 (file)
@@ -418,7 +418,7 @@ class checker : public er {
   bool result;
   bool reset;
  public:
-       checker(void * Abuf, void * Bbuf):er(IS_CHECKING),origBuf((myByte *)Abuf),buf((myByte *)Bbuf),_skip(false),accuracy(0.0),result(true),reset(false) {}
+       checker(void * Abuf, void * Bbuf):er(IS_CHECKING),origBuf((myByte *)Abuf),buf((myByte *)Bbuf),_skip(true),accuracy(0.0),result(true),reset(false) {}
        virtual void setAccuracy(double _accuracy) {
                accuracy = _accuracy;
                //printf("set accuracy %lf\n",accuracy);
index e7874062a7ca17b756eab54b78ba0554d60ef62d..4e4b048db25e24eac863a73a59ca1852917c7555 100644 (file)
@@ -114,7 +114,7 @@ template <class container,class dtype>
 inline void PUP_stl_container(PUP::er &p,container &c) {
   p.syncComment(PUP::sync_begin_array);
   int nElem=PUP_stl_container_size(p,c);
-  if (p.isUnpacking()) 
+  if (p.isUnpacking()||p.isChecking()
   { //Unpacking: Extract each element and push_back:
     c.resize(0);
     for (int i=0;i<nElem;i++) {