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