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