Fixed bugs due to ckfutures declarations in c++interface.h
[charm.git] / src / conv-core / converse.h
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.70  1997-07-28 20:13:23  milind
16  * Fixed bugs due to ckfutures declarations in c++interface.h
17  * Also, wrote macros for node numbering in exemplar.
18  *
19  * Revision 2.69  1997/07/28 19:00:39  jyelon
20  * *** empty log message ***
21  *
22  * Revision 2.68  1997/07/26 16:41:16  jyelon
23  * *** empty log message ***
24  *
25  * Revision 2.67  1997/07/24 18:32:12  jyelon
26  * *** empty log message ***
27  *
28  * Revision 2.66  1997/07/24 17:29:36  milind
29  * Added Parallel Java to the CVS repository in Common/langs.
30  * Fixed a problem with size_t in converse.h
31  *
32  * Revision 2.65  1997/07/23 18:40:22  milind
33  * Made charm++ to work on exemplar.
34  *
35  * Revision 2.64  1997/07/22 18:15:59  milind
36  * fixed some exemplar-related bugs.
37  *
38  * Revision 2.63  1997/07/21 21:00:05  jyelon
39  * added cpthreads.
40  *
41  * Revision 2.62  1997/07/07 23:03:38  rbrunner
42  * Added stdio.h to CMI_PRINTF_IS_BUILTIN block
43  *
44  * Revision 2.61  1997/05/05 13:47:12  jyelon
45  * Revamped threads package using quickthreads.
46  *
47  * Revision 2.60  1997/04/03 20:32:11  milind
48  * Fixed compilation problem due to differing prototype declaration of
49  * CthAutoYield.
50  *
51  * Revision 2.59  1997/04/03 19:42:08  jyelon
52  * Working on threads stuff.
53  *
54  * Revision 2.58  1997/03/25 23:09:00  milind
55  * Got threads to work on 64-bit irix. Had to add JB_TWEAKING_ORIGIN flag to
56  * all the conv-mach.h files. Also, _PAGESZ was undefined on irix. Added
57  * code to memory.c to make it a static variable.
58  *
59  * Revision 2.57  1997/03/19 04:31:04  jyelon
60  * Redesigned ConverseInit
61  *
62  * Revision 2.56  1997/03/17 23:40:23  milind
63  * Added Idle Notification Functionality:
64  * The new Macros in converse.h for this are:
65  * CsdSetNotifyIdle(fn1, fn2)
66  * CsdStartNotifyIdle()
67  * CsdStopNotifyIdle()
68  *
69  * Revision 2.55  1997/02/13 09:31:02  jyelon
70  * Modified everything for new main/ConverseInit structure
71  *
72  * Revision 2.54  1997/02/07 02:15:37  jyelon
73  * Added stuff for byte-order conversion.
74  *
75  * Revision 2.53  1997/02/06 19:53:37  jyelon
76  * Fifo: added peek and pop.  Convcore: added support for new network version.
77  *
78  * Revision 2.52  1997/01/17 15:49:06  jyelon
79  * Made many changes for SMP version.  In particular, memory module now uses
80  * CmiMemLock and CmiMemUnlock instead of CmiInterruptsBlock, which no longer
81  * exists.  Threads package uses CthCpv to declare all its global vars.
82  * Much other restructuring.
83  *
84  * Revision 2.51  1996/11/23 02:25:33  milind
85  * Fixed several subtle bugs in the converse runtime for convex
86  * exemplar.
87  *
88  * Revision 2.50  1996/11/20 06:45:40  jyelon
89  * Repaired rob's HP/C++ mods.
90  *
91  * Revision 2.49  1996/11/08 22:22:51  brunner
92  * Put _main in for HP-UX CC compilation.  It is ignored according to the
93  * CMK_USE_HP_MAIN_FIX flag.
94  *
95  * Revision 2.48  1996/10/24 19:40:21  milind
96  * Added CMK_IS_HETERO to all the net-all versions.
97  *
98  * Revision 2.47  1996/07/16 17:23:18  jyelon
99  * Misc
100  *
101  * Revision 2.46  1996/07/16 09:26:46  milind
102  * Added vector send routines declarations.
103  *
104  * Revision 2.45  1996/07/15  21:02:39  jyelon
105  * Changed mach-flags #ifdef to #if, added timer stuff.
106  *
107  * Revision 2.44  1996/07/02 21:01:55  jyelon
108  * Added CMK_THREADS_USE_JB_TWEAKING
109  *
110  * Revision 2.43  1996/06/24 18:56:25  jyelon
111  * *** empty log message ***
112  *
113  * Revision 2.42  1996/04/17 18:54:36  jyelon
114  * *** empty log message ***
115  *
116  * Revision 2.41  1996/04/16 22:44:42  jyelon
117  * *** empty log message ***
118  *
119  * Revision 2.40  1996/04/15 23:57:04  jyelon
120  * *** empty log message ***
121  *
122  * Revision 2.39  1996/04/07 19:16:52  jyelon
123  * Corrected bug in CmiInterruptsRelease (could lead to reentering sighandler)
124  *
125  * Revision 2.38  1996/02/14 20:46:11  jyelon
126  * *** empty log message ***
127  *
128  * Revision 2.37  1996/01/17 08:04:56  jyelon
129  * *** empty log message ***
130  *
131  * Revision 2.36  1996/01/03 23:18:37  sanjeev
132  * CmiSize prototype should have void * argument
133  *
134  * Revision 2.35  1995/10/31 19:53:21  jyelon
135  * Added 'CMK_THREADS_USE_ALLOCA_WITH_PRAGMA'
136  *
137  * Revision 2.34  1995/10/27  22:37:08  jyelon
138  * Changed NumPe -> NumPes
139  *
140  * Revision 2.33  1995/10/27  21:39:32  jyelon
141  * changed NumPe --> NumPes
142  *
143  * Revision 2.32  1995/10/23  23:09:05  jyelon
144  * *** empty log message ***
145  *
146  * Revision 2.31  1995/10/20  17:29:10  jyelon
147  * *** empty log message ***
148  *
149  * Revision 2.30  1995/10/19  18:22:08  jyelon
150  * *** empty log message ***
151  *
152  * Revision 2.29  1995/10/18  22:20:37  jyelon
153  * Added 'eatstack' threads implementation.
154  *
155  * Revision 2.28  1995/10/13  22:34:07  jyelon
156  * *** empty log message ***
157  *
158  * Revision 2.27  1995/10/13  18:14:10  jyelon
159  * K&R changes, etc.
160  *
161  * Revision 2.26  1995/10/12  20:18:19  sanjeev
162  * modified prototype for CmiPrintf etc.
163  *
164  * Revision 2.25  1995/10/12  18:14:18  jyelon
165  * Added parentheses in macro defs.
166  *
167  * Revision 2.24  1995/10/11  00:36:39  jyelon
168  * Added CmiInterrupt stuff.
169  *
170  * Revision 2.23  1995/09/30  15:03:15  jyelon
171  * A few changes for threaded-uniprocessor version.
172  *
173  * Revision 2.22  1995/09/29  09:51:44  jyelon
174  * Many corrections, added protos, CmiGet-->CmiDeliver, etc.
175  *
176  * Revision 2.21  1995/09/27  22:23:15  jyelon
177  * Many bug-fixes.  Added Cpv macros to threads package.
178  *
179  * Revision 2.20  1995/09/26  18:26:00  jyelon
180  * Added CthSetStrategyDefault, and cleaned up a bit.
181  *
182  * Revision 2.19  1995/09/20  17:22:14  jyelon
183  * Added CthImplemented
184  *
185  * Revision 2.18  1995/09/20  16:36:56  jyelon
186  * *** empty log message ***
187  *
188  * Revision 2.17  1995/09/20  15:09:42  sanjeev
189  * fixed CmiFree, put int CmiSpanTree stuff
190  *
191  * Revision 2.16  1995/09/20  15:04:45  jyelon
192  * *** empty log message ***
193  *
194  * Revision 2.15  1995/09/20  14:58:12  jyelon
195  * Did some work on threads stuff.
196  *
197  * Revision 2.14  1995/09/20  13:16:33  jyelon
198  * Added prototypes for Cth (thread) functions.
199  *
200  * Revision 2.13  1995/09/19  21:43:58  brunner
201  * Moved declaration of CmiTimer here from c++interface.h
202  *
203  * Revision 2.12  1995/09/19  19:31:51  jyelon
204  * Fixed a bug.
205  *
206  * Revision 2.11  1995/09/19  18:57:17  jyelon
207  * added CMK_PREPROCESSOR_USES_ANSI_STANDARD_CONCATENATION and other goodies.
208  *
209  * Revision 2.10  1995/09/07  21:14:15  jyelon
210  * Added prefix to Cpv and Csv macros, then fixed bugs thereby revealed.
211  *
212  * Revision 2.9  1995/07/19  22:18:54  jyelon
213  * *** empty log message ***
214  *
215  * Revision 2.8  1995/07/11  18:10:26  jyelon
216  * Added CsdEnqueueFifo, etc.
217  *
218  * Revision 2.7  1995/07/11  16:52:37  gursoy
219  * CsdExitScheduler is a function for uniprocessor now
220  *
221  * Revision 2.6  1995/07/07  14:04:35  gursoy
222  * redone uniprocessors changes again, somehow an old version
223  * is checked in
224  *
225  * Revision 2.5  1995/07/06  23:22:58  narain
226  * Put back the different components of converse.h in this file.
227  *
228  * Revision 2.4  1995/06/29  21:25:29  narain
229  * Split up converse.h and moved out the functionality to converse?????.h
230  *
231  ***************************************************************************/
232
233 #ifndef CONVERSE_H
234 #define CONVERSE_H
235
236 #ifndef _conv_mach_h
237 #include "conv-mach.h"
238 #endif
239
240 /**** DEAL WITH DIFFERENCES: KERNIGHAN-RITCHIE-C, ANSI-C, AND C++ ****/
241
242 #if CMK_PREPROCESSOR_CANNOT_DO_CONCATENATION
243 #define CMK_CONCAT(x,y) y
244 #endif
245
246 #if CMK_PREPROCESSOR_USES_ANSI_STANDARD_CONCATENATION
247 #define CMK_CONCAT(x,y) x##y
248 #endif
249
250 /* the following flags denote properties of the C compiler,  */
251 /* not the C++ compiler.  If this is C++, ignore them.       */
252 #ifdef __cplusplus
253 #undef CMK_PROTOTYPES_FAIL
254 #undef CMK_PROTOTYPES_WORK
255 #define CMK_PROTOTYPES_FAIL 0
256 #define CMK_PROTOTYPES_WORK 1
257 #undef CMK_PREPROCESSOR_CANNOT_DO_CONCATENATION
258 #undef CMK_PREPROCESSOR_USES_ANSI_STANDARD_CONCATENATION
259 #define CMK_PREPROCESSOR_CANNOT_DO_CONCATENATION 0
260 #define CMK_PREPROCESSOR_USES_ANSI_STANDARD_CONCATENATION 1
261 extern "C" {
262 #endif
263
264 #if CMK_PROTOTYPES_WORK
265 #define CMK_PROTO(x) x
266 #endif
267
268 #if CMK_PROTOTYPES_FAIL
269 #define CMK_PROTO(x) ()
270 #endif
271
272 #if CMK_STATIC_PROTO_WORKS
273 #define CMK_STATIC_PROTO static
274 #endif
275
276 #if CMK_STATIC_PROTO_FAILS
277 #define CMK_STATIC_PROTO extern
278 #endif
279
280 /******************************************************************************
281  *
282  * Deal with Shared Memory
283  *
284  * Shared memory strongly affects how CPV, CSV, and CmiMyPe are defined,
285  * and how memory locking is performed. Therefore, we control all these
286  * functions with a single flag.
287  *
288  *****************************************************************************/
289
290 #if CMK_SHARED_VARS_UNAVAILABLE
291
292 extern int Cmi_mype;
293 extern int Cmi_numpes;
294
295 #define CmiMyPe()           Cmi_mype
296 #define CmiMyRank()         0
297 #define CmiNumPes()         Cmi_numpes
298 #define CmiMyNodeSize()     1
299 #define CmiMyNode()         Cmi_mype
300 #define CmiNumNodes()       Cmi_numpes
301 #define CmiNodeFirst(node)  (node)
302 #define CmiNodeSize(node)   1
303 #define CmiNodeOf(pe)       (pe)
304 #define CmiRankOf(pe)       0
305
306 #define SHARED_DECL
307 #define CpvDeclare(t,v) t CMK_CONCAT(Cpv_Var_,v)
308 #define CpvExtern(t,v)  extern t CMK_CONCAT(Cpv_Var_,v)
309 #define CpvStaticDeclare(t,v) static t CMK_CONCAT(Cpv_Var_,v)
310 #define CpvInitialize(t,v) 
311 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)
312
313 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
314 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
315 #define CsvInitialize(t,v) 
316 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
317 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
318
319 extern void CmiMemLock();
320 extern void CmiMemUnlock();
321 #define CmiNodeBarrier() 0
322 #define CmiSvAlloc CmiAlloc
323 typedef int CmiMutex;
324 #define CmiMutexLock(x) 0
325 #define CmiMutexUnlock(x) 0
326
327 #endif
328
329 #if CMK_SHARED_VARS_EXEMPLAR
330
331 #include <spp_prog_model.h>
332
333 extern int Cmi_numpes;
334 extern int Cmi_mynodesize;
335
336 #define CmiMyPe()           (my_thread())
337 #define CmiMyRank()         (my_thread())
338 #define CmiNumPes()         Cmi_numpes
339 #define CmiMyNodeSize()     Cmi_mynodesize
340 #define CmiMyNode()         0
341 #define CmiNumNodes()       Cmi_numpes
342 #define CmiNodeFirst(node)  0
343 #define CmiNodeSize(node)   Cmi_numpes
344 #define CmiNodeOf(pe)       0
345 #define CmiRankOf(pe)       (pe)
346
347 #define SHARED_DECL
348 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
349 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
350 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
351 #define CpvInitialize(t,v)\
352     { if (CmiMyRank()) while (CMK_CONCAT(Cpv_Var_,v)==0);\
353     else { CMK_CONCAT(Cpv_Var_,v)=(t*)malloc(sizeof(t)*CmiMyNodeSize()); }}
354 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
355
356 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
357 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
358 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
359 #define CsvInitialize(t,v)
360 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
361
362
363 extern void CmiMemLock();
364 extern void CmiMemUnlock();
365 extern void CmiNodeBarrier CMK_PROTO((void));
366 extern void *CmiSvAlloc CMK_PROTO((int));
367
368 #endif
369
370 #if CMK_SHARED_VARS_SUN_THREADS
371
372 #include <thread.h>
373
374 extern int Cmi_numpes;
375 extern int Cmi_mynodesize;
376 extern int Cmi_mynode;
377 extern int Cmi_numnodes;
378
379 extern int CmiMyPe();
380 extern int CmiMyRank();
381 #define CmiNumPes()         Cmi_numpes
382 #define CmiMyNodeSize()     Cmi_mynodesize
383 #define CmiMyNode()         Cmi_mynode
384 #define CmiNumNodes()       Cmi_numnodes
385 extern int CmiNodeFirst(int node);
386 extern int CmiNodeSize(int node);
387 extern int CmiNodeOf(int pe);
388 extern int CmiRankOf(int pe);
389
390 #define SHARED_DECL
391
392 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
393 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
394 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
395 #define CpvInitialize(t,v)\
396   { if (CmiMyRank()) while (CMK_CONCAT(Cpv_Var_,v)==0);\
397     else { CMK_CONCAT(Cpv_Var_,v)=(t*)malloc(sizeof(t)*CmiMyNodeSize()); }}
398 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
399
400 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
401 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
402 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
403 #define CsvInitialize(t,v)
404 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
405
406 extern void CmiMemLock();
407 extern void CmiMemUnlock();
408 #define CmiNodeBarrier() 0
409 #define CmiSvAlloc CmiAlloc
410 typedef mutex_t CmiMutex;
411 #define CmiMutexLock(m) mutex_lock(m)
412 #define CmiMutexUnlock(m) mutex_unlock(m)
413
414 #endif
415
416 #if CMK_SHARED_VARS_UNIPROCESSOR
417
418 extern int Cmi_mype;
419 extern int Cmi_numpes;
420
421 #define CmiMyPe()              Cmi_mype
422 #define CmiMyRank()            Cmi_mype
423 #define CmiNumPes()            Cmi_numpes
424 #define CmiMyNodeSize()        Cmi_numpes
425 #define CmiMyNode()            0
426 #define CmiNumNodes()          1
427 #define CmiNodeFirst(node)     0
428 #define CmiNodeSize(node)      Cmi_numpes
429 #define CmiNodeOf(pe)          0
430 #define CmiRankOf(pe)          (pe)
431
432 #define SHARED_DECL
433
434 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
435 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
436 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
437 #define CpvInitialize(t,v)\
438     { if (CMK_CONCAT(Cpv_Var_,v)==0)\
439         { CMK_CONCAT(Cpv_Var_,v) = (t *)CmiAlloc(CmiNumPes()*sizeof(t)); }}
440 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyPe()]
441
442 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
443 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
444 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
445 #define CsvInitialize(t,v)
446 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
447
448 #define CmiMemLock() 0
449 #define CmiMemUnlock() 0
450 extern void CmiNodeBarrier();
451 #define CmiSvAlloc CmiAlloc
452 typedef int CmiMutex;
453 #define CmiMutexLock(x) 0
454 #define CmiMutexUnlock(x) 0
455
456 #endif
457
458 /******** CMI: TYPE DEFINITIONS ********/
459
460 #define CmiMsgHeaderSizeBytes CMK_MSG_HEADER_SIZE_BYTES
461
462 #if CMK_COMMHANDLE_IS_A_POINTER
463 typedef void  *CmiCommHandle;
464 #endif
465
466 #if CMK_COMMHANDLE_IS_AN_INTEGER
467 typedef int    CmiCommHandle;
468 #endif
469
470
471 typedef void (*CmiHandler)();
472
473 /******** Basic Types ********/
474
475 #ifdef CMK_NUMBERS_NORMAL
476
477 typedef short                   CInt2;
478 typedef int                     CInt4;
479 typedef long long               CInt8;
480 typedef unsigned short          CUInt2;
481 typedef unsigned int            CUInt4;
482 typedef unsigned long long      CUInt8;
483 typedef float                   CFloat4;
484 typedef double                  CFloat8;
485 typedef struct { char c[16]; }  CFloat16;
486
487 #endif
488
489 /******** CMI, CSD: MANY LOW-LEVEL OPERATIONS ********/
490
491 CpvExtern(CmiHandler*, CmiHandlerTable);
492 CpvExtern(void*,       CsdSchedQueue);
493 CpvExtern(int,         CsdStopFlag);
494 CpvExtern(CmiHandler, CsdNotifyIdle);
495 CpvExtern(CmiHandler, CsdNotifyBusy);
496 CpvExtern(int,        CsdStopNotifyFlag);
497
498 extern int CmiRegisterHandler CMK_PROTO((CmiHandler));
499 extern int CmiRegisterHandlerLocal CMK_PROTO((CmiHandler));
500 extern int CmiRegisterHandlerGlobal CMK_PROTO((CmiHandler));
501 extern void CmiNumberHandler CMK_PROTO((int, CmiHandler));
502
503 /*
504  * I'm planning on doing the byte-order conversion slightly differently
505  * now.  The repair of the header will be done in the machine layer,
506  * just after receiving a message.  This will be cheaper than doing it
507  * here.  Since the CMI can only repair the header and not the contents
508  * of the message, we provide these functions that the user can use to
509  * repair the contents of the message.
510  *
511  * CmiConvertInt2(msg, p)
512  * CmiConvertInt4(msg, p)
513  * CmiConvertInt8(msg, p)
514  * CmiConvertFloat4(msg, p)
515  * CmiConvertFloat8(msg, p)
516  * CmiConvertFloat16(msg, p)
517  *
518  *   Given a message and a pointer to a number in that message,
519  *   converts the number in-place.  This accounts for the byte-order
520  *   and other format peculiarities of the sender.
521  *
522  * CmiConversionNeeded(msg)
523  *
524  *   When speed is of the essence, this function may make it possible
525  *   to skip some conversions.  It returns a combination of the following
526  *   flags:
527  *
528  *   CMI_CONVERT_INTS_BACKWARD   - ints are in backward byte-order.
529  *   CMI_CONVERT_INTS_FOREIGN    - ints are in a wildly different format.
530  *   CMI_CONVERT_FLOATS_BACKWARD - floats are in backward byte-order.
531  *   CMI_CONVERT_FLOATS_FOREIGN  - floats are in a wildly different format.
532  *
533  * If neither bit is set, the numbers are in local format, and no
534  * conversion is needed whatsoever.  Thus, a value of 0 indicates that
535  * the message is entirely in local format.  If the values are in wildly
536  * different format, one has no choice but to use the CmiConvert functions.
537  * If they're just in backward-byte-order, you can swap the bytes yourself,
538  * possibly faster than we can.
539  *
540  */
541
542 #define CmiConversionNeeded(m) 0
543 #define CmiConvertInt2(m,p) 0
544 #define CmiConvertInt4(m,p) 0
545 #define CmiConvertInt8(m,p) 0
546 #define CmiConvertFloat4(m,p) 0
547 #define CmiConvertFloat8(m,p) 0
548 #define CmiConvertFloat16(m,p) 0
549
550 #define CmiHandlerAccess(m)\
551   (*((int*)(((char *)(m))+CMK_MSG_HEADER_BLANK_SPACE)))
552
553 #define CmiGetHandler(env)  (CmiHandlerAccess(env))
554 #define CmiSetHandler(env,x)  (CmiHandlerAccess(env) = (x))
555
556 #define CmiGetHandlerFunction(env)\
557     (CpvAccess(CmiHandlerTable)[CmiGetHandler(env)])
558
559 void    *CmiAlloc  CMK_PROTO((int size));
560 int      CmiSize   CMK_PROTO((void *));
561 void     CmiFree   CMK_PROTO((void *));
562
563 double   CmiTimer      CMK_PROTO(());
564 double   CmiWallTimer  CMK_PROTO(());
565 double   CmiCpuTimer   CMK_PROTO(());
566
567 #define CsdEnqueueGeneral(x,s,i,p)\
568     (CqsEnqueueGeneral(CpvAccess(CsdSchedQueue),(x),(s),(i),(p)))
569 #define CsdEnqueueFifo(x)     (CqsEnqueueFifo(CpvAccess(CsdSchedQueue),(x)))
570 #define CsdEnqueueLifo(x)     (CqsEnqueueLifo(CpvAccess(CsdSchedQueue),(x)))
571 #define CsdEnqueue(x)         (CqsEnqueueFifo(CpvAccess(CsdSchedQueue),(x)))
572 #define CsdEmpty()            (CqsEmpty(CpvAccess(CsdSchedQueue)))
573
574 #if CMK_CMIPRINTF_IS_A_BUILTIN
575 void  CmiPrintf CMK_PROTO((char *, ...));
576 void  CmiError  CMK_PROTO((char *, ...));
577 int   CmiScanf  CMK_PROTO((char *, ...));
578 #endif
579
580 #if CMK_CMIPRINTF_IS_JUST_PRINTF
581 #include <stdio.h>
582
583 #define CmiPrintf printf
584 #define CmiError  printf
585 #define CmiScanf  scanf
586 #endif
587
588 typedef void (*CmiStartFn) CMK_PROTO((int argc, char **argv));
589
590 /********* CSD - THE SCHEDULER ********/
591
592 extern  int CsdScheduler CMK_PROTO((int));
593 #define CsdSetNotifyIdle(f1,f2) {CpvAccess(CsdNotifyIdle)=(f1);\
594                                  CpvAccess(CsdNotifyBusy)=(f2);}
595 #define CsdStartNotifyIdle() (CpvAccess(CsdStopNotifyFlag)=0)
596 #define CsdStopNotifyIdle() (CpvAccess(CsdStopNotifyFlag)=1)
597
598 #if CMK_CSDEXITSCHEDULER_IS_A_FUNCTION
599 extern void CsdExitScheduler CMK_PROTO((void));
600 #endif 
601
602 #if CMK_CSDEXITSCHEDULER_SET_CSDSTOPFLAG
603 #define CsdExitScheduler()  (CpvAccess(CsdStopFlag)=1)
604 #endif
605
606 int      CmiSpanTreeRoot         CMK_PROTO(()) ;
607 int      CmiNumSpanTreeChildren  CMK_PROTO((int)) ;
608 int      CmiSpanTreeParent       CMK_PROTO((int)) ;
609 void     CmiSpanTreeChildren     CMK_PROTO((int node, int *children)) ;
610
611 /****** CMI MESSAGE TRANSMISSION ******/
612
613 void          CmiSyncSendFn        CMK_PROTO((int, int, char *));
614 CmiCommHandle CmiAsyncSendFn       CMK_PROTO((int, int, char *));
615 void          CmiFreeSendFn        CMK_PROTO((int, int, char *));
616
617 void          CmiSyncBroadcastFn      CMK_PROTO((int, char *));
618 CmiCommHandle CmiAsyncBroadcastFn     CMK_PROTO((int, char *));
619 void          CmiFreeBroadcastFn      CMK_PROTO((int, char *));
620
621 void          CmiSyncBroadcastAllFn   CMK_PROTO((int, char *));
622 CmiCommHandle CmiAsyncBroadcastAllFn  CMK_PROTO((int, char *));
623 void          CmiFreeBroadcastAllFn   CMK_PROTO((int, char *));
624
625
626 #define CmiSyncSend(p,s,m)              (CmiSyncSendFn((p),(s),(char *)(m)))
627 #define CmiAsyncSend(p,s,m)             (CmiAsyncSendFn((p),(s),(char *)(m)))
628 #define CmiSyncSendAndFree(p,s,m)       (CmiFreeSendFn((p),(s),(char *)(m)))
629
630 #define CmiSyncBroadcast(s,m)           (CmiSyncBroadcastFn((s),(char *)(m)))
631 #define CmiAsyncBroadcast(s,m)          (CmiAsyncBroadcastFn((s),(char *)(m)))
632 #define CmiSyncBroadcastAndFree(s,m)    (CmiFreeBroadcastFn((s),(char *)(m)))
633
634 #define CmiSyncBroadcastAll(s,m)        (CmiSyncBroadcastAllFn((s),(char *)(m)))
635 #define CmiAsyncBroadcastAll(s,m)       (CmiAsyncBroadcastAllFn((s),(char *)(m)))
636 #define CmiSyncBroadcastAllAndFree(s,m) (CmiFreeBroadcastAllFn((s),(char *)(m)))
637
638 /****** CMI VECTOR MESSAGE TRANSMISSION ******/
639
640 void CmiSyncVectorSend CMK_PROTO((int, int, int *, char **));
641 CmiCommHandle CmiAsyncVectorSend CMK_PROTO((int, int, int *, char **));
642 void CmiSyncVectorSendAndFree CMK_PROTO((int, int, int *, char **));
643
644 /******** CMI MESSAGE RECEPTION ********/
645
646 int    CmiDeliverMsgs          CMK_PROTO((int maxmsgs));
647 void   CmiDeliverSpecificMsg   CMK_PROTO((int handler));
648
649 /******** CQS: THE QUEUEING SYSTEM ********/
650
651 #define CQS_QUEUEING_FIFO 2
652 #define CQS_QUEUEING_LIFO 3
653 #define CQS_QUEUEING_IFIFO 4
654 #define CQS_QUEUEING_ILIFO 5
655 #define CQS_QUEUEING_BFIFO 6
656 #define CQS_QUEUEING_BLIFO 7
657
658 /****** CTH: THE LOW-LEVEL THREADS PACKAGE ******/
659
660 typedef struct CthThreadStruct *CthThread;
661
662 typedef void        (*CthVoidFn)();
663 typedef CthThread   (*CthThFn)();
664
665 int        CthImplemented  CMK_PROTO((void));
666
667 CthThread  CthSelf     CMK_PROTO((void));
668 CthThread  CthCreate   CMK_PROTO((CthVoidFn, void *, int));
669 void       CthResume   CMK_PROTO((CthThread));
670 void       CthFree     CMK_PROTO((CthThread));
671
672 void       CthSuspend             CMK_PROTO((void));
673 void       CthAwaken              CMK_PROTO((CthThread));
674 void       CthSetStrategy         CMK_PROTO((CthThread, CthVoidFn, CthThFn));
675 void       CthSetStrategyDefault  CMK_PROTO((CthThread));
676 void       CthYield               CMK_PROTO((void));
677
678 void       CthSetNext CMK_PROTO((CthThread t, CthThread next));
679 CthThread  CthGetNext CMK_PROTO((CthThread t));
680
681 void       CthAutoYield           CMK_PROTO((CthThread t, int flag));
682 double     CthAutoYieldFreq       CMK_PROTO((CthThread t));
683 void       CthAutoYieldBlock      CMK_PROTO((void));
684 void       CthAutoYieldUnblock    CMK_PROTO((void));
685
686 /****** CTH: THREAD-PRIVATE VARIABLES ******/
687
688 #if CMK_THREADS_REQUIRE_NO_CPV
689
690 #define CthCpvDeclare(t,v)    t v
691 #define CthCpvExtern(t,v)     extern t v
692 #define CthCpvStatic(t,v)     static t v
693 #define CthCpvInitialize(t,v) 
694 #define CthCpvAccess(x)       x
695
696 #else
697
698 #define CthCpvDeclare(t,v)    CpvDeclare(t,v)
699 #define CthCpvExtern(t,v)     CpvExtern(t,v)
700 #define CthCpvStatic(t,v)     CpvStaticDeclare(t,v)
701 #define CthCpvInitialize(t,v) CpvInitialize(t,v)
702 #define CthCpvAccess(x)       CpvAccess(x)
703
704 #endif
705
706 CthCpvExtern(char *,CthData);
707 extern int CthRegister CMK_PROTO((int));
708 #define CtvDeclare(t,v)         typedef t CtvType##v; CsvDeclare(int,CtvOffs##v);
709 #define CtvStaticDeclare(t,v)   typedef t CtvType##v; CsvStaticDeclare(int,CtvOffs##v);
710 #define CtvExtern(t,v)          typedef t CtvType##v; CsvExtern(int,CtvOffs##v);
711 #define CtvAccess(v)            (*((CtvType##v *)(CthCpvAccess(CthData)+CsvAccess(CtvOffs##v))))
712 #define CtvInitialize(t,v)      if (CmiMyRank()==0) (CsvAccess(CtvOffs##v)=CthRegister(sizeof(CtvType##v)));
713
714 /************************************************************************
715  *
716  * CpmDestination
717  *
718  * A CpmDestination structure enables the user of the Cpm module to tell
719  * the parameter-marshalling system what kind of envelope to put int the
720  * message, and what to do with it after it has been filled.
721  *
722  ***********************************************************************/
723
724 typedef struct CpmDestinationStruct *CpmDestination;
725
726 typedef void *(*CpmSender) CMK_PROTO((CpmDestination, int, void *));
727
728 struct CpmDestinationStruct
729 {
730   CpmSender sendfn;
731   int envsize;
732 };
733
734 #define CpmPE(n) n
735 #define CpmALL (-1)
736 #define CpmOTHERS (-2)
737
738 CpmDestination CpmSend CMK_PROTO((int pe));
739 CpmDestination CpmMakeThread CMK_PROTO((int pe));
740 CpmDestination CpmMakeThreadSize CMK_PROTO((int pe, int size));
741 CpmDestination CpmEnqueueFIFO CMK_PROTO((int pe));
742 CpmDestination CpmEnqueueLIFO CMK_PROTO((int pe));
743 CpmDestination CpmEnqueueIFIFO CMK_PROTO((int pe, int prio));
744 CpmDestination CpmEnqueueILIFO CMK_PROTO((int pe, int prio));
745 CpmDestination CpmEnqueueBFIFO CMK_PROTO((int pe, int priobits, int *prioptr));
746 CpmDestination CpmEnqueueBLIFO CMK_PROTO((int pe, int priobits, int *prioptr));
747 CpmDestination CpmEnqueue CMK_PROTO((int pe,int qs,int priobits,int *prioptr));
748
749 /***********************************************************************
750  *
751  * CPM macros
752  *
753  *      CpmInvokable
754  *      CpmDeclareSimple(x)
755  *      CpmDeclarePointer(x)
756  *
757  * These macros expand into CPM ``declarations''.  The CPM ``declarations''
758  * are actually C code that has no effect, but when the CPM scanner sees
759  * them, it recognizes them and understands them as declarations.
760  *
761  **********************************************************************/
762
763 typedef void CpmInvokable;
764 typedef int CpmDeclareSimple1;
765 typedef int CpmDeclarePointer1;
766 #define CpmDeclareSimple(c) typedef CpmDeclareSimple1 CpmType_##c
767 #define CpmDeclarePointer(c) typedef CpmDeclarePointer1 CpmType_##c
768
769 /***********************************************************************
770  *
771  * Accessing a CPM message:
772  *
773  ***********************************************************************/
774
775 struct CpmHeader
776 {
777   char convcore[CmiMsgHeaderSizeBytes];
778   int envpos;
779 };
780 #define CpmEnv(msg) (((char *)msg)+(((struct CpmHeader *)msg)->envpos))
781 #define CpmAlign(val, type) ((val+sizeof(type)-1)&(~(sizeof(type)-1)))
782
783 /***********************************************************************
784  *
785  * Built-in CPM types
786  *
787  **********************************************************************/
788
789 CpmDeclareSimple(char);
790 #define CpmPack_char(v)
791 #define CpmUnpack_char(v)
792
793 CpmDeclareSimple(short);
794 #define CpmPack_short(v)
795 #define CpmUnpack_short(v)
796
797 CpmDeclareSimple(int);
798 #define CpmPack_int(v)
799 #define CpmUnpack_int(v)
800
801 CpmDeclareSimple(long);
802 #define CpmPack_long(v)
803 #define CpmUnpack_long(v)
804
805 CpmDeclareSimple(float);
806 #define CpmPack_float(v)
807 #define CpmUnpack_float(v)
808
809 CpmDeclareSimple(double);
810 #define CpmPack_double(v)
811 #define CpmUnpack_double(v)
812
813 typedef int CpmDim;
814 CpmDeclareSimple(CpmDim);
815 #define CpmPack_CpmDim(v)
816 #define CpmUnpack_CpmDim(v)
817
818 CpmDeclareSimple(Cfuture);
819 #define CpmPack_Cfuture(v)
820 #define CpmUnpack_Cfuture(v)
821
822 typedef char *CpmStr;
823 CpmDeclarePointer(CpmStr);
824 #define CpmPtrSize_CpmStr(v) (strlen(v)+1)
825 #define CpmPtrPack_CpmStr(p, v) (strcpy(p, v))
826 #define CpmPtrUnpack_CpmStr(v)
827 #define CpmPtrFree_CpmStr(v)
828
829 /****** CFUTURE: CONVERSE FUTURES ******/
830
831 typedef struct Cfuture_s
832 {
833   int pe;
834   struct Cfuture_data_s *data;
835 }
836 Cfuture;
837
838 #define CfutureValueData(v) ((void*)((v)->rest))
839
840 Cfuture       CfutureCreate(void);
841 void          CfutureSet(Cfuture f, void *val, int len);
842 void         *CfutureWait(Cfuture f);
843 void          CfutureDestroy(Cfuture f);
844
845 void         *CfutureCreateBuffer(int bytes);
846 void          CfutureDestroyBuffer(void *val);
847 void          CfutureStoreBuffer(Cfuture f, void *value);
848
849 #define       CfuturePE(f) ((f).pe)
850
851 void CfutureInit();
852
853 /****** CMM: THE MESSAGE MANAGER ******/
854
855 typedef struct CmmTableStruct *CmmTable;
856
857 #define CmmWildCard (-1)
858
859 CmmTable   CmmNew();
860 void       CmmFree CMK_PROTO((CmmTable t));
861 void       CmmPut CMK_PROTO((CmmTable t, int ntags, int *tags, void *msg));
862 void      *CmmFind CMK_PROTO((CmmTable t, int ntags, int *tags, int *returntags, int del));
863 #define    CmmGet(t,nt,tg,rt)   (CmmFind((t),(nt),(tg),(rt),1))
864 #define    CmmProbe(t,nt,tg,rt) (CmmFind((t),(nt),(tg),(rt),0))
865
866 /******** ConverseInit and ConverseExit ********/
867
868 void ConverseInit CMK_PROTO((int, char**, CmiStartFn, int, int));
869 void ConverseExit CMK_PROTO((void));
870
871 /******** CONVCONDS ********/
872
873 typedef void (*CcdVoidFn)();
874
875 #define CcdPROCESSORIDLE 1
876
877 void CcdCallFnAfter CMK_PROTO((CcdVoidFn fnp, void *arg, unsigned int msecs));
878 void CcdPeriodicallyCall CMK_PROTO((CcdVoidFn fnp, void *arg));
879
880 void CcdRaiseCondition CMK_PROTO((int condnum));
881 void CcdCallOnCondition CMK_PROTO((int condnum, CcdVoidFn fnp, void *arg));
882
883 void CcdCallBacks();
884
885 /**** DEAL WITH DIFFERENCES: KERNIGHAN-RITCHIE-C, ANSI-C, AND C++ ****/
886
887 #if defined(__cplusplus)
888 }
889 #endif
890
891 #endif /* CONVERSE_H */
892