build: fix travis MPI/SMP build
[charm.git] / src / ck-core / ckmemcheckpoint.h
1 #ifndef _CK_MEM_CHECKPT_
2 #define _CK_MEM_CHECKPT_
3
4 #include "CkMemCheckpoint.decl.h"
5
6 extern CkGroupID ckCheckPTGroupID;
7 class CkArrayCheckPTReqMessage: public CMessage_CkArrayCheckPTReqMessage {
8 public: 
9   CkArrayCheckPTReqMessage()  {}
10 };
11
12 class CkArrayCheckPTMessage: public CMessage_CkArrayCheckPTMessage {
13 public:
14         CkArrayID  aid;
15         CkGroupID  locMgr;
16         CkArrayIndex index;
17         double *packData;
18         int bud1, bud2;
19         size_t len;
20         bool cp_flag;          // true: from checkpoint, false: from recover
21 };
22
23
24 class CkProcCheckPTMessage: public CMessage_CkProcCheckPTMessage {
25 public:
26         int pe;
27         int reportPe;           // chkpt starter
28         int failedpe;
29         int cur_restart_phase;
30         size_t len;
31         int pointer;
32         char *packData;
33 };
34
35 // table entry base class
36 class CkCheckPTInfo {
37    friend class CkMemCheckPT;
38 protected:
39    CkArrayID aid;
40    CkGroupID locMgr;
41    CkArrayIndex index;
42    int pNo;   //another buddy
43 public:
44    CkCheckPTInfo();
45    CkCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndex idx, int pno):
46                   aid(a), locMgr(loc), index(idx), pNo(pno)   {}
47    virtual ~CkCheckPTInfo() {}
48    virtual void updateBuffer(CkArrayCheckPTMessage *data) = 0;
49    virtual CkArrayCheckPTMessage * getCopy() = 0;
50    virtual void updateBuddy(int b1, int b2) = 0;
51    virtual size_t getSize() = 0;
52 };
53
54 /// memory or disk checkpointing
55 #define CkCheckPoint_inMEM   1
56 #define CkCheckPoint_inDISK  2
57
58 class CkCheckPTEntry{
59   std::vector<CkArrayCheckPTMessage *> data;
60   std::string fname;
61 public:
62   int bud1, bud2;
63   int where;
64   void init(int _where, int idx)
65   {
66     data.resize(2, NULL);
67     where = _where;
68     if(where == CkCheckPoint_inDISK)
69     {
70 #if CMK_USE_MKSTEMP
71 #if CMK_CONVERSE_MPI
72       fname = "/tmp/ckpt" + std::to_string(CmiMyPartition()) + "-" + std::to_string(CkMyPe()) + "-" + std::to_string(idx) + "-XXXXXX";
73 #else
74       fname = "/tmp/ckpt" + std::to_string(CkMyPe()) + "-" + std::to_string(idx) + "-XXXXXX";
75 #endif
76       if(mkstemp(&fname[0])<0)
77         {
78           CmiAbort("mkstemp fail in checkpoint");
79         }
80 #else
81       fname = tmpnam(NULL);
82 #endif
83     }
84   }
85
86   void updateBuffer(int pointer, CkArrayCheckPTMessage * msg)
87   {
88     if(where == CkCheckPoint_inDISK)
89     {
90       envelope *env = UsrToEnv(msg);
91       CkUnpackMessage(&env);
92       data[pointer] = (CkArrayCheckPTMessage *)EnvToUsr(env);
93       FILE *f = fopen(fname.c_str(),"wb");
94       PUP::toDisk p(f);
95       CkPupMessage(p, (void **)&msg);
96       // delay sync to the end because otherwise the messages are blocked
97   //    fsync(fileno(f));
98       fclose(f);
99       bud1 = msg->bud1;
100       bud2 = msg->bud2;
101       delete msg;
102     }else
103     {
104       CmiAssert(where == CkCheckPoint_inMEM);
105       CmiAssert(msg!=NULL);
106       delete data[pointer];
107       data[pointer] = msg;
108       bud1 = msg->bud1;
109       bud2 = msg->bud2;
110     }
111   }
112   
113   CkArrayCheckPTMessage * getCopy(int pointer)
114   {
115     if(where == CkCheckPoint_inDISK)
116     {
117       CkArrayCheckPTMessage *msg;
118       FILE *f = fopen(fname.c_str(),"rb");
119       PUP::fromDisk p(f);
120       CkPupMessage(p, (void **)&msg);
121       fclose(f);
122       msg->bud1 = bud1;                         // update the buddies
123       msg->bud2 = bud2;
124       return msg;
125     }else
126     {
127       CmiAssert(where == CkCheckPoint_inMEM);
128       if (data[pointer] == NULL) {
129         CmiPrintf("[%d] recoverArrayElements: element does not have checkpoint data.", CkMyPe());
130         CmiAbort("Abort!");
131       }
132       return (CkArrayCheckPTMessage *)CkCopyMsg((void **)&data[pointer]);
133     }
134   }
135 };
136
137
138 class CkMemCheckPT: public CBase_CkMemCheckPT {
139 public:
140   CkMemCheckPT(int w);
141   CkMemCheckPT(CkMigrateMessage *m):CBase_CkMemCheckPT(m) {};
142   virtual ~CkMemCheckPT();
143   void pup(PUP::er& p);
144   inline int BuddyPE(int pe);
145   void doItNow(int sp, CkCallback &&);
146   void restart(int diePe);
147   void removeArrayElements();
148   void createEntry(CkArrayID aid, CkGroupID loc, CkArrayIndex index, int buddy);
149   void recvData(CkArrayCheckPTMessage *);
150   void gotData();
151   void recvProcData(CkProcCheckPTMessage *);
152   void cpFinish();
153   void syncFiles(void);
154   void report();
155   void recoverBuddies();
156   void recoverEntry(CkArrayCheckPTMessage *msg);
157   void recoverArrayElements();
158   void quiescence(CkCallback &&);
159   void resetReductionMgr();
160   void finishUp();
161   void gotReply();
162   void inmem_restore(CkArrayCheckPTMessage *m);
163   void updateLocations(int n, CkGroupID *g, CkArrayIndex *idx, CmiUInt8 *id, int nowOnPe);
164   void resetLB(int diepe);
165   bool isFailed(int pe);
166   void pupAllElements(PUP::er &p);
167   void startArrayCheckpoint();
168   void recvArrayCheckpoint(CkArrayCheckPTMessage *m);
169   void recoverAll(CkArrayCheckPTMessage * msg, std::vector<CkGroupID> * gmap=NULL, std::vector<CkArrayIndex> * imap=NULL);
170 public:
171   static CkCallback  cpCallback;
172
173   static bool inRestarting;
174   static bool inCheckpointing;
175   static bool inLoadbalancing;
176   static double startTime;
177   static char*  stage;
178
179 private:
180   std::vector<CkCheckPTInfo *> ckTable;
181   CkCheckPTEntry chkpTable[2];
182
183   int recvCount, peCount;
184   int expectCount, ackCount;
185   int recvChkpCount;//expect to receive both the processor checkpoint and array checkpoint from buddy PE
186   /// the processor who initiate the checkpointing
187   int cpStarter;
188   std::vector<int> failedPes;
189   int thisFailedPe;
190
191     /// to use memory or disk checkpointing
192   int    where;
193 private:
194   void initEntry();
195   inline bool isMaster(int pe);
196
197   void failed(int pe);
198   int  totalFailed();
199
200   void sendProcData();
201 };
202
203 // called in initCharm
204 void CkMemRestart(const char *, CkArgMsg *);
205
206 // called by user applications
207 // to start a checkpointing
208 void CkStartMemCheckpoint(CkCallback &cb);
209
210 // true if inside a restarting phase
211 extern "C" int CkInRestarting();
212 extern "C" int CkInLdb();
213 extern "C" void CkSetInLdb(); 
214 extern "C" void CkResetInLdb();
215
216 extern "C" int CkHasCheckpoints();
217
218 void CkDieNow();
219
220 #endif