721eb44dd81e483fd995cf0336b57faaf0bafe22
[charm.git] / src / ck-core / main.c
1 /***************************************************************************
2  * RCS INFORMATION:
3  *
4  *      $RCSfile$
5  *      $Author$        $Locker$                $State$
6  *      $Revision$      $Date$
7  *
8  ***************************************************************************
9  * DESCRIPTION:
10  *
11  ***************************************************************************
12  * REVISION HISTORY:
13  *
14  * $Log$
15  * Revision 2.29  1998-02-27 11:52:06  jyelon
16  * Cleaned up header files, replaced load-balancer.
17  *
18  * Revision 2.28  1998/01/28 17:52:49  milind
19  * Removed unnecessary function calls to tracing functions.
20  * Added macros to turn tracing on and off at runtime.
21  *
22  * Revision 2.27  1997/12/12 05:03:43  jyelon
23  * Fixed bug, wasn't doing CmiGrabBuffer.
24  *
25  * Revision 2.26  1997/07/18 21:21:09  milind
26  * all files of the form perf-*.c have been changed to trace-*.c, with
27  * name expansions. For example, perf-proj.c has been changed to
28  * trace-projections.c.
29  * performance.h has been renamed as trace.h, and perfio.c has been
30  * renamed as traceio.c.
31  * Corresponding changes have been made in the Makefile too.
32  * Earlier, there used to be three libck-core-*.a where * was projections,
33  * summary or none. Now, there will be a single libck-core.a and
34  * three libck-trace-*.a where *=projections, summary and none.
35  * The execmode parameter to charmc script has been renamed as
36  * tracemode.
37  * Also, the perfModuleInit function has been renamed as traceModuleInit,
38  * RecdPerfMsg => RecdTraceMsg
39  * CollectPerfFromNodes => CollectTraceFromNodes
40  *
41  * Revision 2.25  1997/07/18 19:14:52  milind
42  * Fixed the perfModuleInit call to pass command-line params.
43  * Also added trace_enqueue call to Charm message handler.
44  *
45  * Revision 2.24  1996/02/10 18:11:11  sanjeev
46  * fixed bug: if(CpvAccess(InsideDataInit)) CldStripLdb(LDB_ELEMENT_PTR(env));
47  *
48  * Revision 2.23  1995/11/06 00:17:26  sanjeev
49  * in CkProcess_ForChareMsg, magic number taken from chareblock, not env
50  *
51  * Revision 2.22  1995/10/13  18:15:53  jyelon
52  * K&R changes.
53  *
54  * Revision 2.21  1995/10/11  17:54:40  sanjeev
55  * fixed Charm++ chare creation
56  *
57  * Revision 2.20  1995/09/29  09:51:12  jyelon
58  * Many small corrections.
59  *
60  * Revision 2.19  1995/09/20  16:36:26  jyelon
61  * *** empty log message ***
62  *
63  * Revision 2.18  1995/09/20  15:41:38  gursoy
64  * removed the if form handle incoming message
65  *
66  * Revision 2.17  1995/09/20  14:24:27  jyelon
67  * *** empty log message ***
68  *
69  * Revision 2.16  1995/09/07  05:27:11  gursoy
70  * modified HANDLE_INCOMING_MSG to buffer messages
71  *
72  * Revision 2.15  1995/09/06  21:48:50  jyelon
73  * Eliminated 'CkProcess_BocMsg', using 'CkProcess_ForChareMsg' instead.
74  *
75  * Revision 2.14  1995/09/06  04:08:51  sanjeev
76  * fixed bugs
77  *
78  * Revision 2.13  1995/09/05  22:01:29  sanjeev
79  * modified CkProcess_ForChareMsg, CkProcess_NewChareMsg, CkProcess_BocMsg
80  * to integrate Charm++
81  *
82  * Revision 2.12  1995/09/01  02:13:17  jyelon
83  * VID_BLOCK, CHARE_BLOCK, BOC_BLOCK consolidated.
84  *
85  * Revision 2.11  1995/07/27  20:29:34  jyelon
86  * Improvements to runtime system, general cleanup.
87  *
88  * Revision 2.10  1995/07/25  00:29:31  jyelon
89  * *** empty log message ***
90  *
91  * Revision 2.9  1995/07/24  01:54:40  jyelon
92  * *** empty log message ***
93  *
94  * Revision 2.8  1995/07/22  23:44:13  jyelon
95  * *** empty log message ***
96  *
97  * Revision 2.7  1995/07/19  22:15:28  jyelon
98  * *** empty log message ***
99  *
100  * Revision 2.6  1995/07/12  16:28:45  jyelon
101  * *** empty log message ***
102  *
103  * Revision 2.5  1995/07/06  22:42:11  narain
104  * Changes for LDB interface revision
105  *
106  * Revision 2.4  1995/07/05  21:04:11  narain
107  * *** empty log message ***
108  *
109  * Revision 2.3  1995/07/05  19:38:31  narain
110  * No CldFillBlock and CldStripMsg while InsideDataInit
111  *
112  * Revision 2.2  1995/06/29  21:44:50  narain
113  * Added macros for CldStripMsg and CldNewChareFromNet
114  *
115  * Revision 2.1  1995/06/08  17:07:12  gursoy
116  * Cpv macro changes done
117  *
118  * Revision 1.11  1995/05/03  20:57:07  sanjeev
119  * bug fixes for finding uninitialized modules
120  *
121  * Revision 1.10  1995/04/24  20:17:13  sanjeev
122  * fixed typo
123  *
124  * Revision 1.9  1995/04/23  20:53:26  sanjeev
125  * Removed Core....
126  *
127  * Revision 1.8  1995/04/13  20:54:53  sanjeev
128  * Changed Mc to Cmi
129  *
130  * Revision 1.7  1995/03/25  18:23:59  sanjeev
131  * *** empty log message ***
132  *
133  * Revision 1.6  1995/03/23  22:12:51  sanjeev
134  * *** empty log message ***
135  *
136  * Revision 1.5  1995/03/17  23:35:04  sanjeev
137  * changes for better message format
138  *
139  * Revision 1.4  1995/03/09  22:21:53  sanjeev
140  * fixed bug in BlockingLoop
141  *
142  * Revision 1.3  1994/12/01  23:55:10  sanjeev
143  * interop stuff
144  *
145  * Revision 1.2  1994/11/18  20:32:17  narain
146  * Added a parameter (number of iterations) to Loop()
147  * Added functions DoCharm and EndCharm (main seperation)
148  *  - Sanjeev and Narain
149  *
150  * Revision 1.1  1994/11/03  17:38:31  brunner
151  * Initial revision
152  *
153  ***************************************************************************/
154 static char ident[] = "@(#)$Header$";
155
156
157 /*************************************************************************/
158 /** This file now contains only the Charm/Charm++ part of the run-time.
159     The core (scheduler/Converse) part is in converse.c                  */
160 /*************************************************************************/
161
162 #include "charm.h"
163
164 #include "trace.h"
165
166 CHARE_BLOCK *GetBocBlockPtr();
167
168 extern void CkLdbSend();
169 void HANDLE_INCOMING_MSG();
170
171 void mainModuleInit()
172 {
173 }
174
175 void CheckMagicNumber(chare, env)
176     CHARE_BLOCK *chare; ENVELOPE *env;
177 {
178   if (GetID_chare_magic_number(chare->selfID) !=
179       GetEnv_chare_magic_number(env)) {
180     CmiPrintf("[%d] *** ERROR *** dead chare or bad chareID used at entry point %s.\n", 
181               CmiMyPe(), CsvAccess(EpInfoTable)[GetEnv_EP(env)].name);
182     exit(1);
183   }
184 }
185
186 void CkProcess_ForChareMsg_to_UVID(env)
187 ENVELOPE *env;
188 {
189   if(CpvAccess(traceOn))
190     trace_begin_execute(env);
191   VidEnqueueMsg(env);
192   if(CpvAccess(traceOn))
193     trace_end_execute(0, ForChareMsg, 0);
194   QDCountThisProcessing(ForChareMsg);
195 }
196
197 void CkProcess_ForChareMsg_to_FVID(env)
198 ENVELOPE *env;
199 {
200   if(CpvAccess(traceOn))
201     trace_begin_execute(env);
202   VidForwardMsg(env);
203   if(CpvAccess(traceOn))
204     trace_end_execute(0, ForChareMsg, 0);
205   QDCountThisProcessing(ForChareMsg);
206 }
207
208 void CkProcess_ForChareMsg_to_Chare(env)
209 ENVELOPE *env;
210 {
211   CHARE_BLOCK *chareblock;
212   int          current_ep;
213   EP_STRUCT   *current_epinfo;
214   void        *current_usr;
215   int          current_magic;
216   int          current_msgType;
217
218   chareblock      = GetEnv_chareBlockPtr(env);
219   current_ep      = GetEnv_EP(env);
220   current_epinfo  = CsvAccess(EpInfoTable) + current_ep;
221   current_usr     = USER_MSG_PTR(env);
222   current_magic   = chareblock->selfID.magic;
223   current_msgType = GetEnv_msgType(env);
224
225   CpvAccess(currentChareBlock) = (void *)chareblock;
226   CpvAccess(nodeforCharesProcessed)++;
227   if(CpvAccess(traceOn))
228     trace_begin_execute(env);
229   (current_epinfo->function)(current_usr,chareblock->chareptr);
230   if(CpvAccess(traceOn))
231     trace_end_execute(current_magic, current_msgType, current_ep);
232   QDCountThisProcessing(current_msgType);
233 }
234
235 void CkProcess_ForChareMsg(env)
236 ENVELOPE *env;
237 {
238   CHARE_BLOCK *chare = GetEnv_chareBlockPtr(env);
239   CheckMagicNumber(chare, env);
240   switch (chare->charekind) {
241   case CHAREKIND_UVID: CkProcess_ForChareMsg_to_UVID(env); break;
242   case CHAREKIND_FVID: CkProcess_ForChareMsg_to_FVID(env); break;
243   case CHAREKIND_CHARE: CkProcess_ForChareMsg_to_Chare(env); break;
244   case CHAREKIND_BOCNODE: CkProcess_ForChareMsg_to_Chare(env); break;
245   }
246 }
247
248 void CkProcess_BocMsg(env)
249 ENVELOPE *env;
250 {
251   CHARE_BLOCK *chare;
252   chare = GetBocBlockPtr(GetEnv_boc_num(env));
253   SetEnv_chareBlockPtr(env, chare);
254   CkProcess_ForChareMsg_to_Chare(env);
255 }
256
257 void CkProcess_DynamicBocInitMsg(env)
258 ENVELOPE *env;
259 {
260   /* ProcessBocInitMsg handles Charm++ bocs properly */
261   /* This process of registering the new boc using the */
262   /* spanning tree is exactly the same for Charm++ */
263   int current_msgType, executing_boc_num;
264
265   current_msgType = GetEnv_msgType(env);
266   executing_boc_num = ProcessBocInitMsg(env);
267   RegisterDynamicBocInitMsg(&executing_boc_num, NULL);
268   QDCountThisProcessing(current_msgType);
269 }
270
271 void CkProcess_NewChareMsg(env)
272 ENVELOPE *env;
273 {
274   int current_ep, current_msgType, current_magic, current_chare;
275   void *current_usr;
276   CHARE_BLOCK *current_block;
277   EP_STRUCT *current_epinfo;
278   CHARE_BLOCK *CreateChareBlock();
279
280   current_ep = GetEnv_EP(env);
281   current_epinfo = CsvAccess(EpInfoTable) + current_ep;
282   current_chare = current_epinfo->chareindex;
283   current_usr = USER_MSG_PTR(env);
284   current_msgType = GetEnv_msgType(env);
285   current_magic = CpvAccess(nodecharesProcessed)++;
286   CpvAccess(currentChareBlock) = current_block = CreateChareBlock(
287                                     CsvAccess(ChareSizesTable)[current_chare],
288                                     CHAREKIND_CHARE, current_magic);
289
290   /* If virtual block exists, get all messages for this chare   */
291   if (GetEnv_vidBlockPtr(env))
292     VidRetrieveMessages(current_block,
293             GetEnv_vidPE(env),
294             GetEnv_vidBlockPtr(env));
295
296   /* Now call the entry point : For Charm, this is the actual call to the 
297      EP function. For Charm++, this is a call to the translator-generated
298      stub function which does "new ChareType(msg)". 
299      NOTE: CreateChareBlock sets current_block->chareptr to (current_block + 1)
300      because ChareSizesTable[] holds the correct size of the chare for both 
301      Charm and Charm++, so it allocates the correct amount of space.
302      - Sanjeev 10/10/95 */
303
304   if(CpvAccess(traceOn))
305     trace_begin_execute(env);
306   (current_epinfo->function)(current_usr, current_block->chareptr);
307   if(CpvAccess(traceOn))
308     trace_end_execute(current_magic, current_msgType, current_ep);
309   QDCountThisProcessing(current_msgType);
310 }
311
312 void CkProcess_VidSendOverMsg(env)
313 ENVELOPE *env;
314 {
315   int current_msgType; void *current_usr;
316   
317   current_msgType = GetEnv_msgType(env);
318   current_usr = USER_MSG_PTR(env);
319   if(CpvAccess(traceOn))
320     trace_begin_execute(env);
321   VidSendOverMessages(current_usr, NULL);
322   if(CpvAccess(traceOn))
323     trace_end_execute(0, current_msgType, 0);
324   QDCountThisProcessing(current_msgType);
325 }
326
327
328
329
330 /* This is the message handler for non-init messages during the
331    initialization phase. It simply buffers the messafe */
332 void BUFFER_INCOMING_MSG(env)
333 ENVELOPE *env;
334 {
335   if (CpvAccess(CkInitPhase)) {
336     CmiGrabBuffer(&env);
337     FIFO_EnQueue(CpvAccess(CkBuffQueue),(void *)env);
338   } else {
339     HANDLE_INCOMING_MSG(env);
340   }
341 }
342
343
344 /* This is the handler function for Charm and Charm++, which is called
345    immediately when a message is received (from self or network) */
346
347 void HANDLE_INCOMING_MSG(env)
348 ENVELOPE *env;
349 {
350   CmiGrabBuffer(&env);
351   UNPACK(env);
352   if(CpvAccess(traceOn))
353     trace_enqueue(env);
354   switch (GetEnv_msgType(env)) {
355   case NewChareMsg:          CkProcess_NewChareMsg(env); break;
356   case ForChareMsg:          CkProcess_ForChareMsg(env); break;
357   case LdbMsg:               CkProcess_BocMsg(env); break;
358   case QdBocMsg:             CkProcess_BocMsg(env); break;
359   case QdBroadcastBocMsg:    CkProcess_BocMsg(env); break;
360   case ImmBocMsg:            CkProcess_BocMsg(env); break;
361   case ImmBroadcastBocMsg:   CkProcess_BocMsg(env); break;
362   case BocMsg:               CkProcess_BocMsg(env); break;
363   case BroadcastBocMsg:      CkProcess_BocMsg(env); break;
364   case VidSendOverMsg:       CkProcess_VidSendOverMsg(env); break;
365   case DynamicBocInitMsg:    CkProcess_DynamicBocInitMsg(env); break;
366   case NewChareNoBalanceMsg:
367     CmiAbort("** ERROR ** obsolete message type.\n");
368   default:
369     CmiAbort("** ERROR ** bad message type.\n");
370   }
371 }
372
373