Added ability to determine if an address is managed by Isomalloc.
[charm.git] / src / conv-core / converse.h
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 #ifndef CONVERSE_H
9 #define CONVERSE_H
10
11 #ifndef _conv_mach_h
12 #include "conv-mach.h"
13 #include "conv-autoconfig.h"
14 #endif
15
16 /**** DEAL WITH DIFFERENCES: KERNIGHAN-RITCHIE-C, ANSI-C, AND C++ ****/
17
18 #define CMK_CONCAT(x,y) x##y
19
20 #include "pup_c.h"
21
22 /* the following flags denote properties of the C compiler,  */
23 /* not the C++ compiler.  If this is C++, ignore them.       */
24 #ifdef __cplusplus
25
26 /* Only C++ needs this backup bool defined.  We'll assume that C doesn't
27    use it */
28
29 #if CMK_BOOL_UNDEFINED
30 enum CmiBool {CmiFalse=0, CmiTrue=1};
31 #else
32 typedef bool CmiBool;
33 #define CmiFalse false
34 #define CmiTrue true
35 #endif
36
37 extern "C" {
38 #endif
39
40 /******************************************************************************
41  *
42  * Deal with Shared Memory
43  *
44  * Shared memory strongly affects how CPV, CSV, and CmiMyPe are defined,
45  * and how memory locking is performed. Therefore, we control all these
46  * functions with a single flag.
47  *
48  *****************************************************************************/
49
50 #if CMK_SHARED_VARS_UNAVAILABLE
51
52 extern int Cmi_mype;
53 extern int Cmi_numpes;
54
55 #define CmiMyPe()           Cmi_mype
56 #define CmiMyRank()         0
57 #define CmiNumPes()         Cmi_numpes
58 #define CmiMyNodeSize()     1
59 #define CmiMyNode()         Cmi_mype
60 #define CmiNumNodes()       Cmi_numpes
61 #define CmiNodeFirst(node)  (node)
62 #define CmiNodeSize(node)   1
63 #define CmiNodeOf(pe)       (pe)
64 #define CmiRankOf(pe)       0
65
66 #define SHARED_DECL
67 #define CpvDeclare(t,v) t CMK_CONCAT(Cpv_Var_,v)
68 #define CpvExtern(t,v)  extern t CMK_CONCAT(Cpv_Var_,v)
69 #define CpvStaticDeclare(t,v) static t CMK_CONCAT(Cpv_Var_,v)
70 #define CpvInitialize(t,v) do {} while(0)
71 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)
72
73 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
74 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
75 #define CsvInitialize(t,v) do{}while(0)
76 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
77 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
78
79 extern void CmiMemLock();
80 extern void CmiMemUnlock();
81 #define CmiNodeBarrier() /*empty*/
82 #define CmiSvAlloc CmiAlloc
83
84 typedef void *CmiNodeLock;
85 #define CmiCreateLock() ((void *)0)
86 #define CmiLock(lock) /*empty*/
87 #define CmiUnlock(lock) /*empty*/
88 #define CmiTryLock(lock) /*empty*/
89 #define CmiDestroyLock(lock) /*empty*/
90
91 #endif
92
93 #if CMK_SHARED_VARS_EXEMPLAR
94
95 #include <spp_prog_model.h>
96 #include <cps.h>
97
98 extern int Cmi_numpes;
99 extern int Cmi_mynodesize;
100
101 #define CmiMyPe()           (my_thread())
102 #define CmiMyRank()         (my_thread())
103 #define CmiNumPes()         Cmi_numpes
104 #define CmiMyNodeSize()     Cmi_numpes
105 #define CmiMyNode()         0
106 #define CmiNumNodes()       1
107 #define CmiNodeFirst(node)  0
108 #define CmiNodeSize(node)   Cmi_numpes
109 #define CmiNodeOf(pe)       0
110 #define CmiRankOf(pe)       (pe)
111
112 #define SHARED_DECL
113 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
114 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
115 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
116 #define CpvInitialize(t,v)\
117     do { if (CmiMyRank()) CmiNodeBarrier();\
118     else { CMK_CONCAT(Cpv_Var_,v)=(t*)malloc(sizeof(t)*CmiMyNodeSize());\
119            CmiNodeBarrier();}} while(0)
120 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
121
122 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
123 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
124 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
125 #define CsvInitialize(t,v) do{}while(0)
126 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
127
128
129 extern void CmiMemLock();
130 extern void CmiMemUnlock();
131 extern void CmiNodeBarrier(void);
132 extern void *CmiSvAlloc(int);
133
134 typedef cps_mutex_t *CmiNodeLock;
135 extern CmiNodeLock CmiCreateLock(void);
136 #define CmiLock(lock) (cps_mutex_lock(lock))
137 #define CmiUnlock(lock) (cps_mutex_unlock(lock))
138 #define CmiTryLock(lock) (cps_mutex_trylock(lock))
139 #define CmiDestroyLock(lock) (cps_mutex_free(lock))
140
141 #endif
142
143 #if CMK_SHARED_VARS_POSIX_THREADS_SMP
144
145 #include <pthread.h>
146 #include <sched.h>
147 #ifdef CMK_FAKE_SCHED_YIELD
148 #include <unistd.h>
149 #define sched_yield() sleep(0)
150 #endif
151
152 extern int Cmi_numpes;
153 extern int Cmi_mynodesize;
154 extern int Cmi_mynode;
155 extern int Cmi_numnodes;
156
157 extern int CmiMyPe();
158 extern int CmiMyRank();
159 #define CmiNumPes()         Cmi_numpes
160 #define CmiMyNodeSize()     Cmi_mynodesize
161 #define CmiMyNode()         Cmi_mynode
162 #define CmiNumNodes()       Cmi_numnodes
163 extern int CmiNodeFirst(int node);
164 extern int CmiNodeSize(int node);
165 extern int CmiNodeOf(int pe);
166 extern int CmiRankOf(int pe);
167
168 #define SHARED_DECL
169
170 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
171 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
172 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
173 #define CpvInitialize(t,v)\
174   do { if (CmiMyRank()) while (CMK_CONCAT(Cpv_Var_,v)==0) sched_yield();\
175        else { CMK_CONCAT(Cpv_Var_,v)=(t*)malloc(sizeof(t)*CmiMyNodeSize()); }}\
176   while(0)
177 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
178
179 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
180 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
181 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
182 #define CsvInitialize(t,v) do{}while(0)
183 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
184
185 extern void CmiNodeBarrier(void);
186 #define CmiSvAlloc CmiAlloc
187
188 typedef pthread_mutex_t *CmiNodeLock;
189 extern CmiNodeLock CmiCreateLock();
190 #define CmiLock(lock) (pthread_mutex_lock(lock))
191 #define CmiUnlock(lock) (pthread_mutex_unlock(lock))
192 #define CmiTryLock(lock) (pthread_mutex_trylock(lock))
193 extern void CmiDestroyLock(CmiNodeLock lock);
194
195 extern CmiNodeLock CmiMemLock_lock;
196 #define CmiMemLock() do{if (CmiMemLock_lock) CmiLock(CmiMemLock_lock);} while (0)
197 #define CmiMemUnlock() do{if (CmiMemLock_lock) CmiUnlock(CmiMemLock_lock);} while (0)
198
199 #endif
200
201 #if CMK_SHARED_VARS_UNIPROCESSOR
202
203 extern int Cmi_mype;
204 extern int Cmi_numpes;
205
206 #define CmiMyPe()              Cmi_mype
207 #define CmiMyRank()            Cmi_mype
208 #define CmiNumPes()            Cmi_numpes
209 #define CmiMyNodeSize()        Cmi_numpes
210 #define CmiMyNode()            0
211 #define CmiNumNodes()          1
212 #define CmiNodeFirst(node)     0
213 #define CmiNodeSize(node)      Cmi_numpes
214 #define CmiNodeOf(pe)          0
215 #define CmiRankOf(pe)          (pe)
216
217 #define SHARED_DECL
218
219 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
220 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
221 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
222 #define CpvInitialize(t,v)\
223   do  { if (CMK_CONCAT(Cpv_Var_,v)==0)\
224         { CMK_CONCAT(Cpv_Var_,v) = (t *)CmiAlloc(CmiNumPes()*sizeof(t)); }}\
225   while(0)
226 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyPe()]
227
228 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
229 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
230 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
231 #define CsvInitialize(t,v) do{}while(0)
232 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
233
234 #define CmiMemLock() 0
235 #define CmiMemUnlock() 0
236 extern void CmiNodeBarrier();
237 #define CmiSvAlloc CmiAlloc
238
239 typedef int *CmiNodeLock;
240 extern CmiNodeLock  CmiCreateLock(void);
241 extern void         CmiLock(CmiNodeLock lock);
242 extern void         CmiUnlock(CmiNodeLock lock);
243 extern int          CmiTryLock(CmiNodeLock lock);
244 extern void         CmiDestroyLock(CmiNodeLock lock);
245
246 #endif
247
248 #if CMK_SHARED_VARS_PTHREADS
249
250 #include <pthread.h>
251 #include <sched.h>
252
253 extern int CmiMyPe();
254 extern int Cmi_numpes;
255
256 #define CmiNumPes()            Cmi_numpes
257 #define CmiMyRank()            CmiMyPe()
258 #define CmiMyNodeSize()        Cmi_numpes
259 #define CmiMyNode()            0
260 #define CmiNumNodes()          1
261 #define CmiNodeFirst(node)     0
262 #define CmiNodeSize(node)      Cmi_numpes
263 #define CmiNodeOf(pe)          0
264 #define CmiRankOf(pe)          (pe)
265
266 #define SHARED_DECL
267
268 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
269 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
270 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
271 #define CpvInitialize(t,v)\
272   do { if (CmiMyRank()) while (CMK_CONCAT(Cpv_Var_,v)==0) sched_yield();\
273        else {CMK_CONCAT(Cpv_Var_,v)=(t*)CmiAlloc(sizeof(t)*CmiMyNodeSize());}}\
274   while(0)
275 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
276
277 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
278 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
279 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
280 #define CsvInitialize(t,v) do{}while(0)
281 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
282
283 extern void CmiMemLock();
284 extern void CmiMemUnlock();
285 extern void CmiNodeBarrier();
286 #define CmiSvAlloc CmiAlloc
287
288 typedef pthread_mutex_t *CmiNodeLock;
289 extern CmiNodeLock  CmiCreateLock(void);
290 extern void         CmiLock(CmiNodeLock lock);
291 extern void         CmiUnlock(CmiNodeLock lock);
292 extern int          CmiTryLock(CmiNodeLock lock);
293 extern void         CmiDestroyLock(CmiNodeLock lock);
294
295 #endif
296
297 #if CMK_SHARED_VARS_NT_THREADS
298
299 #include <windows.h>
300
301 extern int Cmi_numpes;
302 extern int Cmi_mynodesize;
303 extern int Cmi_mynode;
304 extern int Cmi_numnodes;
305
306 extern int CmiMyPe();
307 extern int CmiMyRank();
308 #define CmiNumPes()         Cmi_numpes
309 #define CmiMyNodeSize()     Cmi_mynodesize
310 #define CmiMyNode()         Cmi_mynode
311 #define CmiNumNodes()       Cmi_numnodes
312 extern int CmiNodeFirst(int node);
313 extern int CmiNodeSize(int node);
314 extern int CmiNodeOf(int pe);
315 extern int CmiRankOf(int pe);
316
317 #define SHARED_DECL
318
319 #define CpvDeclare(t,v) t* CMK_CONCAT(Cpv_Var_,v)
320 #define CpvExtern(t,v)  extern t* CMK_CONCAT(Cpv_Var_,v)
321 #define CpvStaticDeclare(t,v) static t* CMK_CONCAT(Cpv_Var_,v)
322 #define CpvInitialize(t,v)\
323  do { if (CmiMyRank()) while (CMK_CONCAT(Cpv_Var_,v)==0) Sleep(0);\
324     else { CMK_CONCAT(Cpv_Var_,v)=(t*)malloc(sizeof(t)*CmiMyNodeSize()); }} \
325  while(0)
326 #define CpvAccess(v) CMK_CONCAT(Cpv_Var_,v)[CmiMyRank()]
327
328 #define CsvDeclare(t,v) t CMK_CONCAT(Csv_Var_,v)
329 #define CsvStaticDeclare(t,v) static t CMK_CONCAT(Csv_Var_,v)
330 #define CsvExtern(t,v) extern t CMK_CONCAT(Csv_Var_,v)
331 #define CsvInitialize(t,v) do{}while(0)
332 #define CsvAccess(v) CMK_CONCAT(Csv_Var_,v)
333
334 extern void CmiNodeBarrier(void);
335 #define CmiSvAlloc CmiAlloc
336
337
338 typedef HANDLE CmiNodeLock;
339 extern  CmiNodeLock CmiCreateLock(void);
340 #define CmiLock(lock) (WaitForSingleObject(lock, INFINITE))
341 #define CmiUnlock(lock) (ReleaseMutex(lock))
342 #define CmiTryLock(lock) (WaitForSingleObject(lock, 0))
343 extern  void CmiDestroyLock(CmiNodeLock lock);
344
345 extern CmiNodeLock CmiMemLock_lock;
346 #define CmiMemLock() do{if (CmiMemLock_lock) CmiLock(CmiMemLock_lock);} while (0)
347 #define CmiMemUnlock() do{if (CmiMemLock_lock) CmiUnlock(CmiMemLock_lock);} while (0)
348
349 #endif
350
351
352 /******** CMI: TYPE DEFINITIONS ********/
353
354 typedef CMK_TYPEDEF_INT2      CmiInt2;
355 typedef CMK_TYPEDEF_INT4      CmiInt4;
356 typedef CMK_TYPEDEF_INT8      CmiInt8;
357 typedef CMK_TYPEDEF_UINT2     CmiUInt2;
358 typedef CMK_TYPEDEF_UINT4     CmiUInt4;
359 typedef CMK_TYPEDEF_UINT8     CmiUInt8;
360 typedef CMK_TYPEDEF_FLOAT4    CmiFloat4;
361 typedef CMK_TYPEDEF_FLOAT8    CmiFloat8;
362
363 typedef void  *CmiCommHandle;
364 typedef void (*CmiHandler)();
365
366 typedef struct CMK_MSG_HEADER_BASIC CmiMsgHeaderBasic;
367 typedef struct CMK_MSG_HEADER_EXT   CmiMsgHeaderExt;
368
369 #define CmiMsgHeaderSizeBytes (sizeof(CmiMsgHeaderBasic))
370 #define CmiExtHeaderSizeBytes (sizeof(CmiMsgHeaderExt))
371
372 /******** CMI, CSD: MANY LOW-LEVEL OPERATIONS ********/
373
374 CpvExtern(CmiHandler*, CmiHandlerTable);
375 CpvExtern(int,         CmiHandlerMax);
376 CpvExtern(void*,       CsdSchedQueue);
377 #if CMK_NODE_QUEUE_AVAILABLE
378 CsvExtern(void*,       CsdNodeQueue);
379 CsvExtern(CmiNodeLock, CsdNodeQueueLock);
380 #endif
381 CpvExtern(int,         CsdStopFlag);
382
383 extern int CmiRegisterHandler(CmiHandler);
384 extern int CmiRegisterHandlerLocal(CmiHandler);
385 extern int CmiRegisterHandlerGlobal(CmiHandler);
386 extern void CmiNumberHandler(int, CmiHandler);
387
388 #define CmiGetHandler(m)  (((CmiMsgHeaderExt*)m)->hdl)
389 #define CmiGetXHandler(m) (((CmiMsgHeaderExt*)m)->xhdl)
390 #define CmiGetInfo(m)     (((CmiMsgHeaderExt*)m)->info)
391
392 #define CmiSetHandler(m,v)  do {((((CmiMsgHeaderExt*)m)->hdl)=(v));} while(0)
393 #define CmiSetXHandler(m,v) do {((((CmiMsgHeaderExt*)m)->xhdl)=(v));} while(0)
394 #define CmiSetInfo(m,v)     do {((((CmiMsgHeaderExt*)m)->info)=(v));} while(0)
395
396 #define CmiHandlerToFunction(n) (CpvAccess(CmiHandlerTable)[n])
397 #define CmiGetHandlerFunction(env) (CmiHandlerToFunction(CmiGetHandler(env)))
398
399 void    *CmiAlloc(int size);
400 int      CmiSize(void *);
401 void     CmiFree(void *);
402
403 double   CmiTimer(void);
404 double   CmiWallTimer(void);
405 double   CmiCpuTimer(void);
406
407 #if CMK_NODE_QUEUE_AVAILABLE
408
409 #define CsdNodeEnqueueGeneral(x,s,i,p) do { \
410           CmiLock(CsvAccess(CsdNodeQueueLock));\
411           CqsEnqueueGeneral(CsvAccess(CsdNodeQueue),(x),(s),(i),(p)); \
412           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
413         } while(0)
414 #define CsdNodeEnqueueFifo(x)     do { \
415           CmiLock(CsvAccess(CsdNodeQueueLock));\
416           CqsEnqueueFifo(CsvAccess(CsdNodeQueue),(x)); \
417           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
418         } while(0)
419 #define CsdNodeEnqueueLifo(x)     do { \
420           CmiLock(CsvAccess(CsdNodeQueueLock));\
421           CqsEnqueueLifo(CsvAccess(CsdNodeQueue),(x))); \
422           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
423         } while(0)
424 #define CsdNodeEnqueue(x)     do { \
425           CmiLock(CsvAccess(CsdNodeQueueLock));\
426           CqsEnqueueFifo(CsvAccess(CsdNodeQueue),(x));\
427           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
428         } while(0)
429
430 #define CsdNodeEmpty()            (CqsEmpty(CpvAccess(CsdNodeQueue)))
431 #define CsdNodeLength()           (CqsLength(CpvAccess(CsdNodeQueue)))
432
433 #else
434
435 #define CsdNodeEnqueueGeneral(x,s,i,p) (CsdEnqueueGeneral(x,s,i,p))
436 #define CsdNodeEnqueueFifo(x) (CqsEnqueueFifo(CpvAccess(CsdSchedQueue),(x)))
437 #define CsdNodeEnqueueLifo(x) (CqsEnqueueLifo(CpvAccess(CsdSchedQueue),(x)))
438 #define CsdNodeEnqueue(x)     (CsdEnqueue(x))
439 #define CsdNodeEmpty()        (CqsEmpty(CpvAccess(CsdSchedQueue)))
440 #define CsdNodeLength()       (CqsLength(CpvAccess(CsdSchedQueue)))
441
442 #endif
443
444 #define CsdEnqueueGeneral(x,s,i,p)\
445     (CqsEnqueueGeneral(CpvAccess(CsdSchedQueue),(x),(s),(i),(p)))
446 #define CsdEnqueueFifo(x)     (CqsEnqueueFifo(CpvAccess(CsdSchedQueue),(x)))
447 #define CsdEnqueueLifo(x)     (CqsEnqueueLifo(CpvAccess(CsdSchedQueue),(x)))
448 #define CsdEnqueue(x)         (CqsEnqueueFifo(CpvAccess(CsdSchedQueue),(x)))
449 #define CsdEmpty()            (CqsEmpty(CpvAccess(CsdSchedQueue)))
450 #define CsdLength()           (CqsLength(CpvAccess(CsdSchedQueue)))
451
452 #if CMK_CMIPRINTF_IS_A_BUILTIN
453 void  CmiPrintf(const char *, ...);
454 void  CmiError(const char *, ...);
455 int   CmiScanf(const char *, ...);
456 #endif
457
458 #if CMK_CMIPRINTF_IS_JUST_PRINTF
459 #include <stdio.h>
460
461 /*
462  * I made vprintf functions for CmiPrintf and CmiError, but on the
463  * O2K, there is no equivalent vscanf!
464
465  #define CmiPrintf printf
466  #define CmiError  printf
467 */
468 #include <stdarg.h>
469
470 void  CmiPrintf(const char *format, ...);
471 void  CmiError(const char *format, ...);
472 #define CmiScanf  scanf
473
474 #endif
475
476 #if CMK_OPTIMIZE
477 #define CmiAssert(expr) ((void) 0)
478 #else
479 #if defined(__STDC__) || defined(__cplusplus)
480 #define __CMK_STRING(x) #x
481 #else
482 #define __CMK_STRING(x) "x"
483 #endif
484 extern void __cmi_assert(const char *, const char *, int);
485 #define CmiAssert(expr) \
486   ((void) ((expr) ? 0 :                   \
487      (__cmi_assert (__CMK_STRING(expr), __FILE__, __LINE__), 0)))
488 #endif
489
490 typedef void (*CmiStartFn)(int argc, char **argv);
491
492 /********* CSD - THE SCHEDULER ********/
493
494 CpvExtern(int, _ccd_numchecks);
495 extern void  CcdCallBacks();
496 #define CsdPeriodic() do{ if (CpvAccess(_ccd_numchecks)-- <= 0) CcdCallBacks(); } while(0)
497
498 extern void  CsdEndIdle(void);
499 extern void  CsdStillIdle(void);
500 extern void  CsdBeginIdle(void);
501
502 typedef struct {
503   void *localQ;
504   void *nodeQ;
505   void *schedQ;
506   CmiNodeLock nodeLock;
507 } CsdSchedulerState_t;
508 extern void CsdSchedulerState_new(CsdSchedulerState_t *state);
509 extern void *CsdNextMessage(CsdSchedulerState_t *state);
510
511 extern void  *CmiGetNonLocal(void);
512 extern void   CmiNotifyIdle(void);
513
514 /*Different kinds of schedulers: generic, eternal, counting, polling*/
515 extern  int CsdScheduler(int maxmsgs);
516 extern void CsdScheduleForever(void);
517 extern  int CsdScheduleCount(int maxmsgs);
518 extern void CsdSchedulePoll(void);
519
520 #define CsdExitScheduler()  (CpvAccess(CsdStopFlag)++)
521
522 #if CMK_SPANTREE_USE_COMMON_CODE
523
524 #define SPANTREE_W  (CMK_SPANTREE_MAXSPAN)
525 #define NN (CmiNumNodes())
526 #define CmiNodeSpanTreeParent(n) ((n)?(((n)-1)/SPANTREE_W):(-1))
527 #define CmiNodeSpanTreeChildren(n,c) do {\
528           int _i; \
529           for(_i=0; _i<SPANTREE_W; _i++) { \
530             int _x = (n)*SPANTREE_W+_i+1; \
531             if(_x<NN) (c)[_i]=_x; \
532           }\
533         } while(0)
534 #define CmiNumNodeSpanTreeChildren(n) ((((n)+1)*SPANTREE_W<NN)? SPANTREE_W : \
535           ((((n)*SPANTREE_W+1)>=NN)?0:((NN-1)-(n)*SPANTREE_W)))
536 #define R(p) (CmiRankOf(p))
537 #define NF(n) (CmiNodeFirst(n))
538 #define SP(n) (CmiNodeSpanTreeParent(n))
539 #define ND(p) (CmiNodeOf(p))
540 #define NS(p) (CmiNodeSize(ND(p)))
541 #define CmiSpanTreeParent(p) ((p)?(R(p)?(NF(ND(p))+R(p)/SPANTREE_W):NF(SP(ND(p)))):(-1))
542 #define C(p) (((R(p)+1)*SPANTREE_W<NS(p))?SPANTREE_W:(((R(p)*SPANTREE_W+1)>=NS(p))?0:((NS(p)-1)-R(p)*SPANTREE_W)))
543 #define SC(p) (CmiNumNodeSpanTreeChildren(ND(p)))
544 #define CmiNumSpanTreeChildren(p) (R(p)?C(p):(SC(p)+C(p)))
545 #define CmiSpanTreeChildren(p,c) do {\
546           int _i,_c=0; \
547           if(R(p)==0) { \
548             for(_i=0;_i<SPANTREE_W;_i++) { \
549               int _x = ND(p)*SPANTREE_W+_i+1; \
550               if(_x<NN) (c)[_c++]=NF(_x); \
551             }\
552           } \
553           for(_i=0;_i<SPANTREE_W;_i++) { \
554             int _x = R(p)*SPANTREE_W+_i+1; \
555             if(_x<NS(p)) (c)[_c++]=NF(ND(p))+_x; \
556           }\
557         } while(0)
558 #endif
559
560 #if CMK_SPANTREE_USE_SPECIAL_CODE
561 int      CmiSpanTreeNumChildren(int) ;
562 int      CmiSpanTreeParent(int) ;
563 void     CmiSpanTreeChildren(int node, int *children);
564 int      CmiNodeSpanTreeNumChildren(int);
565 int      CmiNodeSpanTreeParent(int) ;
566 void     CmiNodeSpanTreeChildren(int node, int *children) ;
567 #endif
568
569 /****** MULTICAST GROUPS ******/
570
571 typedef CMK_MULTICAST_GROUP_TYPE CmiGroup;
572
573 CmiGroup CmiEstablishGroup(int npes, int *pes);
574 void     CmiLookupGroup(CmiGroup grp, int *npes, int **pes);
575
576 /****** CMI MESSAGE TRANSMISSION ******/
577
578 void          CmiSyncSendFn(int, int, char *);
579 CmiCommHandle CmiAsyncSendFn(int, int, char *);
580 void          CmiFreeSendFn(int, int, char *);
581
582 void          CmiSyncBroadcastFn(int, char *);
583 CmiCommHandle CmiAsyncBroadcastFn(int, char *);
584 void          CmiFreeBroadcastFn(int, char *);
585
586 void          CmiSyncBroadcastAllFn(int, char *);
587 CmiCommHandle CmiAsyncBroadcastAllFn(int, char *);
588 void          CmiFreeBroadcastAllFn(int, char *);
589
590 void          CmiSyncListSendFn(int, int *, int, char*);
591 CmiCommHandle CmiAsyncListSendFn(int, int *, int, char*);
592 void          CmiFreeListSendFn(int, int *, int, char*);
593
594 void          CmiSyncMulticastFn(CmiGroup, int, char*);
595 CmiCommHandle CmiAsyncMulticastFn(CmiGroup, int, char*);
596 void          CmiFreeMulticastFn(CmiGroup, int, char*);
597
598 void          CmiSyncVectorSend(int, int, int *, char **);
599 CmiCommHandle CmiAsyncVectorSend(int, int, int *, char **);
600 void          CmiSyncVectorSendAndFree(int, int, int *, char **);
601 void          CmiMultipleSend(unsigned int, int, int *, char **);
602
603 #define CmiSyncSend(p,s,m)              (CmiSyncSendFn((p),(s),(char *)(m)))
604 #define CmiAsyncSend(p,s,m)             (CmiAsyncSendFn((p),(s),(char *)(m)))
605 #define CmiSyncSendAndFree(p,s,m)       (CmiFreeSendFn((p),(s),(char *)(m)))
606
607 #define CmiSyncBroadcast(s,m)           (CmiSyncBroadcastFn((s),(char *)(m)))
608 #define CmiAsyncBroadcast(s,m)          (CmiAsyncBroadcastFn((s),(char *)(m)))
609 #define CmiSyncBroadcastAndFree(s,m)    (CmiFreeBroadcastFn((s),(char *)(m)))
610
611 #define CmiSyncBroadcastAll(s,m)        (CmiSyncBroadcastAllFn((s),(char *)(m)))
612 #define CmiAsyncBroadcastAll(s,m)       (CmiAsyncBroadcastAllFn((s),(char *)(m)))
613 #define CmiSyncBroadcastAllAndFree(s,m) (CmiFreeBroadcastAllFn((s),(char *)(m)))
614
615 #define CmiSyncListSend(n,l,s,m)        (CmiSyncListSendFn((n),(l),(s),(char *)(m)))
616 #define CmiAsyncListSend(n,l,s,m)       (CmiAsyncListSendFn((n),(l),(s),(char *)(m)))
617 #define CmiSyncListSendAndFree(n,l,s,m) (CmiFreeListSendFn((n),(l),(s),(char *)(m)))
618
619 #define CmiSyncMulticast(g,s,m)         (CmiSyncMulticastFn((g),(s),(char*)(m)))
620 #define CmiAsyncMulticast(g,s,m)        (CmiAsyncMulticastFn((g),(s),(char*)(m)))
621 #define CmiSyncMulticastAndFree(g,s,m)  (CmiFreeMulticastFn((g),(s),(char*)(m)))
622
623 #if CMK_NODE_QUEUE_AVAILABLE
624 void          CmiSyncNodeSendFn(int, int, char *);
625 CmiCommHandle CmiAsyncNodeSendFn(int, int, char *);
626 void          CmiFreeNodeSendFn(int, int, char *);
627
628 void          CmiSyncNodeBroadcastFn(int, char *);
629 CmiCommHandle CmiAsyncNodeBroadcastFn(int, char *);
630 void          CmiFreeNodeBroadcastFn(int, char *);
631
632 void          CmiSyncNodeBroadcastAllFn(int, char *);
633 CmiCommHandle CmiAsyncNodeBroadcastAllFn(int, char *);
634 void          CmiFreeNodeBroadcastAllFn(int, char *);
635 #endif
636
637 #if CMK_NODE_QUEUE_AVAILABLE
638 #define CmiSyncNodeSend(p,s,m)          (CmiSyncNodeSendFn((p),(s),(char *)(m)))
639 #define CmiAsyncNodeSend(p,s,m)             (CmiAsyncNodeSendFn((p),(s),(char *)(m)))
640 #define CmiSyncNodeSendAndFree(p,s,m)       (CmiFreeNodeSendFn((p),(s),(char *)(m)))
641 #define CmiSyncNodeBroadcast(s,m)           (CmiSyncNodeBroadcastFn((s),(char *)(m)))
642 #define CmiAsyncNodeBroadcast(s,m)          (CmiAsyncNodeBroadcastFn((s),(char *)(m)))
643 #define CmiSyncNodeBroadcastAndFree(s,m)    (CmiFreeNodeBroadcastFn((s),(char *)(m)))
644 #define CmiSyncNodeBroadcastAll(s,m)        (CmiSyncNodeBroadcastAllFn((s),(char *)(m)))
645 #define CmiAsyncNodeBroadcastAll(s,m)       (CmiAsyncNodeBroadcastAllFn((s),(char *)(m)))
646 #define CmiSyncNodeBroadcastAllAndFree(s,m) (CmiFreeNodeBroadcastAllFn((s),(char *)(m)))
647 #else
648 #define CmiSyncNodeSend(n,s,m)        CmiSyncSend(CmiNodeFirst(n),s,m)
649 #define CmiAsyncNodeSend(n,s,m)       CmiAsyncSend(CmiNodeFirst(n),s,m)
650 #define CmiSyncNodeSendAndFree(n,s,m) CmiSyncSendAndFree(CmiNodeFirst(n),s,m)
651 #define CmiSyncNodeBroadcast(s,m)           do { \
652           int _i; \
653           for(_i=0; _i<CmiNumNodes(); _i++) \
654             if(_i != CmiMyNode()) \
655               CmiSyncSend(CmiNodeFirst(_i),s,m); \
656         } while(0)
657 #define CmiAsyncNodeBroadcast(s,m)          CmiSyncNodeBroadcast(s,m)
658 #define CmiSyncNodeBroadcastAndFree(s,m)    do { \
659           CmiSyncNodeBroadcast(s,m); \
660           CmiFree(m); \
661         } while(0)
662 #define CmiSyncNodeBroadcastAll(s,m)           do { \
663           int _i; \
664           for(_i=0; _i<CmiNumNodes(); _i++) \
665             CmiSyncSend(CmiNodeFirst(_i),s,m); \
666         } while(0)
667 #define CmiAsyncNodeBroadcastAll(s,m)       CmiSyncNodeBroadcastAll(s,m)
668 #define CmiSyncNodeBroadcastAllAndFree(s,m) do { \
669           CmiSyncNodeBroadcastAll(s,m); \
670           CmiFree(m); \
671         } while(0)
672 #endif
673
674 /******** CMI MESSAGE RECEPTION ********/
675
676 int    CmiDeliverMsgs(int maxmsgs);
677 void   CmiDeliverSpecificMsg(int handler);
678 void   CmiHandleMessage(void *msg);
679
680 /******** CQS: THE QUEUEING SYSTEM ********/
681
682 #define CQS_QUEUEING_FIFO 2
683 #define CQS_QUEUEING_LIFO 3
684 #define CQS_QUEUEING_IFIFO 4
685 #define CQS_QUEUEING_ILIFO 5
686 #define CQS_QUEUEING_BFIFO 6
687 #define CQS_QUEUEING_BLIFO 7
688
689 /****** Isomalloc Memory Allocation ********/
690 struct CmiIsomallocBlock {
691         int slot; /*First mapped slot*/
692         int nslots; /*Number of mapped slots*/
693 };
694 typedef struct CmiIsomallocBlock CmiIsomallocBlock;
695
696 void *CmiIsomalloc(int size,CmiIsomallocBlock *b);
697 void *CmiIsomallocPup(pup_er p,CmiIsomallocBlock *b);
698 void  CmiIsomallocFree(CmiIsomallocBlock *b);
699 int   CmiIsomallocInRange(void *addr);
700
701 /****** CTH: THE LOW-LEVEL THREADS PACKAGE ******/
702
703 typedef struct CthThreadStruct *CthThread;
704
705 typedef void        (*CthVoidFn)();
706 typedef void        (*CthAwkFn)(CthThread,int,
707                                 int prioBits,unsigned int *prioptr);
708 typedef CthThread   (*CthThFn)();
709
710 int        CthImplemented(void);
711
712 CthThread  CthPup(pup_er, CthThread);
713
714 CthThread  CthSelf(void);
715 CthThread  CthCreate(CthVoidFn, void *, int);
716 CthThread  CthCreateMigratable(CthVoidFn, void *, int);
717 void       CthResume(CthThread);
718 void       CthFree(CthThread);
719
720 void       CthSetSuspendable(CthThread, int);
721 int        CthIsSuspendable(CthThread);
722
723 void       CthSuspend(void);
724 void       CthAwaken(CthThread);
725 void       CthAwakenPrio(CthThread, int, int, unsigned int *);
726 void       CthSetStrategy(CthThread, CthAwkFn, CthThFn);
727 void       CthSetStrategyDefault(CthThread);
728 void       CthYield(void);
729 void       CthYieldPrio(int,int,unsigned int*);
730
731 void       CthSetNext(CthThread t, CthThread next);
732 CthThread  CthGetNext(CthThread t);
733
734 void       CthAutoYield(CthThread t, int flag);
735 double     CthAutoYieldFreq(CthThread t);
736 void       CthAutoYieldBlock(void);
737 void       CthAutoYieldUnblock(void);
738
739 /****** CTH: THREAD-PRIVATE VARIABLES ******/
740
741 #if CMK_THREADS_REQUIRE_NO_CPV
742
743 #define CthCpvDeclare(t,v)    t v
744 #define CthCpvExtern(t,v)     extern t v
745 #define CthCpvStatic(t,v)     static t v
746 #define CthCpvInitialize(t,v) do {} while(0)
747 #define CthCpvAccess(x)       x
748
749 #else
750
751 #define CthCpvDeclare(t,v)    CpvDeclare(t,v)
752 #define CthCpvExtern(t,v)     CpvExtern(t,v)
753 #define CthCpvStatic(t,v)     CpvStaticDeclare(t,v)
754 #define CthCpvInitialize(t,v) CpvInitialize(t,v)
755 #define CthCpvAccess(x)       CpvAccess(x)
756
757 #endif
758
759 CthCpvExtern(char *,CthData);
760 extern int CthRegister(int);
761 extern char *CthGetData(CthThread t);
762
763 #define CtvDeclare(t,v)         typedef t CtvType##v; CsvDeclare(int,CtvOffs##v)=(-1)
764 #define CtvStaticDeclare(t,v)   typedef t CtvType##v; CsvStaticDeclare(int,CtvOffs##v)=(-1)
765 #define CtvExtern(t,v)          typedef t CtvType##v; CsvExtern(int,CtvOffs##v)
766 #define CtvAccess(v)            (*((CtvType##v *)(CthCpvAccess(CthData)+CsvAccess(CtvOffs##v))))
767 #define CtvAccessOther(t,v)            (*((CtvType##v *)(CthGetData(t)+CsvAccess(CtvOffs##v))))
768 #define CtvInitialize(t,v)      do { \
769         if(CsvAccess(CtvOffs##v)==(-1)) \
770                 CsvAccess(CtvOffs##v)=CthRegister(sizeof(CtvType##v));\
771         else CthRegister(sizeof(CtvType##v));\
772 } while(0)
773
774 /************************************************************************
775  *
776  * CpmDestination
777  *
778  * A CpmDestination structure enables the user of the Cpm module to tell
779  * the parameter-marshalling system what kind of envelope to put int the
780  * message, and what to do with it after it has been filled.
781  *
782  ***********************************************************************/
783
784 typedef struct CpmDestinationStruct *CpmDestination;
785
786 typedef void *(*CpmSender)(CpmDestination, int, void *);
787
788 struct CpmDestinationStruct
789 {
790   CpmSender sendfn;
791   int envsize;
792 };
793
794 #define CpmPE(n) n
795 #define CpmALL (-1)
796 #define CpmOTHERS (-2)
797
798 CpmDestination CpmSend(int pe);
799 CpmDestination CpmMakeThread(int pe);
800 CpmDestination CpmMakeThreadSize(int pe, int size);
801 CpmDestination CpmEnqueueFIFO(int pe);
802 CpmDestination CpmEnqueueLIFO(int pe);
803 CpmDestination CpmEnqueueIFIFO(int pe, int prio);
804 CpmDestination CpmEnqueueILIFO(int pe, int prio);
805 CpmDestination CpmEnqueueBFIFO(int pe, int priobits, unsigned int *prioptr);
806 CpmDestination CpmEnqueueBLIFO(int pe, int priobits, unsigned int *prioptr);
807 CpmDestination CpmEnqueue(int pe,int qs,int priobits,unsigned int *prioptr);
808
809 /***********************************************************************
810  *
811  * CPM macros
812  *
813  *      CpmInvokable
814  *      CpmDeclareSimple(x)
815  *      CpmDeclarePointer(x)
816  *
817  * These macros expand into CPM ``declarations''.  The CPM ``declarations''
818  * are actually C code that has no effect, but when the CPM scanner sees
819  * them, it recognizes them and understands them as declarations.
820  *
821  **********************************************************************/
822
823 typedef void CpmInvokable;
824 typedef int CpmDeclareSimple1;
825 typedef int CpmDeclarePointer1;
826 #define CpmDeclareSimple(c) typedef CpmDeclareSimple1 CpmType_##c
827 #define CpmDeclarePointer(c) typedef CpmDeclarePointer1 CpmType_##c
828
829 /***********************************************************************
830  *
831  * Accessing a CPM message:
832  *
833  ***********************************************************************/
834
835 struct CpmHeader
836 {
837   char convcore[CmiMsgHeaderSizeBytes];
838   int envpos;
839 };
840 #define CpmEnv(msg) (((char *)msg)+(((struct CpmHeader *)msg)->envpos))
841 #define CpmAlign(val, type) ((val+sizeof(type)-1)&(~(sizeof(type)-1)))
842
843 /***********************************************************************
844  *
845  * Built-in CPM types
846  *
847  **********************************************************************/
848
849 CpmDeclareSimple(char);
850 #define CpmPack_char(v) do{}while(0)
851 #define CpmUnpack_char(v) do{}while(0)
852
853 CpmDeclareSimple(short);
854 #define CpmPack_short(v) do{}while(0)
855 #define CpmUnpack_short(v) do{}while(0)
856
857 CpmDeclareSimple(int);
858 #define CpmPack_int(v) do{}while(0)
859 #define CpmUnpack_int(v) do{}while(0)
860
861 CpmDeclareSimple(long);
862 #define CpmPack_long(v) do{}while(0)
863 #define CpmUnpack_long(v) do{}while(0)
864
865 CpmDeclareSimple(float);
866 #define CpmPack_float(v) do{}while(0)
867 #define CpmUnpack_float(v) do{}while(0)
868
869 CpmDeclareSimple(double);
870 #define CpmPack_double(v) do{}while(0)
871 #define CpmUnpack_double(v) do{}while(0)
872
873 typedef int CpmDim;
874 CpmDeclareSimple(CpmDim);
875 #define CpmPack_CpmDim(v) do{}while(0)
876 #define CpmUnpack_CpmDim(v) do{}while(0)
877
878 CpmDeclareSimple(Cfuture);
879 #define CpmPack_Cfuture(v) do{}while(0)
880 #define CpmUnpack_Cfuture(v) do{}while(0)
881
882 typedef char *CpmStr;
883 CpmDeclarePointer(CpmStr);
884 #define CpmPtrSize_CpmStr(v) (strlen(v)+1)
885 #define CpmPtrPack_CpmStr(p, v) (strcpy(p, v))
886 #define CpmPtrUnpack_CpmStr(v) do{}while(0)
887 #define CpmPtrFree_CpmStr(v) do{}while(0)
888
889 /****** CFUTURE: CONVERSE FUTURES ******/
890
891 typedef struct Cfuture_s
892 {
893   int pe;
894   struct Cfuture_data_s *data;
895 }
896 Cfuture;
897
898 #define CfutureValueData(v) ((void*)((v)->rest))
899
900 Cfuture       CfutureCreate(void);
901 void          CfutureSet(Cfuture f, void *val, int len);
902 void         *CfutureWait(Cfuture f);
903 void          CfutureDestroy(Cfuture f);
904
905 void         *CfutureCreateBuffer(int bytes);
906 void          CfutureDestroyBuffer(void *val);
907 void          CfutureStoreBuffer(Cfuture f, void *value);
908
909 #define       CfuturePE(f) ((f).pe)
910
911 void CfutureInit();
912
913 /****** CLD: THE LOAD BALANCER ******/
914
915 #define CLD_ANYWHERE (-1)
916 #define CLD_BROADCAST (-2)
917 #define CLD_BROADCAST_ALL (-3)
918
919 typedef void (*CldPackFn)(void *msg);
920
921 typedef void (*CldInfoFn)(void *msg, 
922                           CldPackFn *packer,
923                           int *len,
924                           int *queueing,
925                           int *priobits, 
926                           unsigned int **prioptr);
927
928 typedef int (*CldEstimator)(void);
929
930 int CldRegisterInfoFn(CldInfoFn fn);
931 int CldRegisterPackFn(CldPackFn fn);
932 void CldRegisterEstimator(CldEstimator fn);
933 int CldEstimate(void);
934 char *CldGetStrategy(void);
935
936 void CldEnqueue(int pe, void *msg, int infofn);
937 void CldEnqueueMulti(int npes, int *pes, void *msg, int infofn);
938 void CldNodeEnqueue(int node, void *msg, int infofn);
939
940 /****** CMM: THE MESSAGE MANAGER ******/
941
942 typedef struct CmmTableStruct *CmmTable;
943
944 #define CmmWildCard (-1)
945
946 CmmTable CmmPup(pup_er, CmmTable);
947
948 CmmTable   CmmNew();
949 void       CmmFree(CmmTable t);
950 void       CmmPut(CmmTable t, int ntags, int *tags, void *msg);
951 void      *CmmFind(CmmTable t, int ntags, int *tags, int *returntags, int del);
952 int        CmmEntries(CmmTable t);
953 #define    CmmGet(t,nt,tg,rt)   (CmmFind((t),(nt),(tg),(rt),1))
954 #define    CmmProbe(t,nt,tg,rt) (CmmFind((t),(nt),(tg),(rt),0))
955
956 /******** ConverseInit and ConverseExit ********/
957
958 void ConverseInit(int, char**, CmiStartFn, int, int);
959 void ConverseExit(void);
960
961 void CmiAbort(const char *);
962
963 #if CMK_MEMCHECK_OFF
964 #define _MEMCHECK(p) do{}while(0)
965 #else
966 #define _MEMCHECK(p) do { \
967                          if ((p)==0) CmiAbort("Memory Allocation Failure.\n");\
968                      } while(0)
969 #endif
970
971 /*********** CPATH ***********/
972
973 typedef struct
974 {
975   int    seqno;
976   short  creator;
977   short  startfn;
978   short  mapfn;
979   short  nsizes;
980   int    sizes[13];
981 }
982 CPath;
983
984 #define CPathArrayDimensions(a) ((a)->nsizes)
985 #define CPathArrayDimension(a,n) ((a)->sizes[n])
986
987 #define CPATH_WILD (-1)
988
989 typedef unsigned int (*CPathMapFn)(CPath *path, int *indices);
990 typedef void (*CPathReduceFn)(int nelts,void *updateme,void *inputme);
991
992 #define CPathRegisterMapper(x)   CmiRegisterHandler((CmiHandler)(x))
993 #define CPathRegisterThreadFn(x) CmiRegisterHandler((CmiHandler)(x))
994 #define CPathRegisterReducer(x)  CmiRegisterHandler((CmiHandler)(x))
995
996 void CPathMakeArray(CPath *path, int startfn, int mapfn, ...);
997 void CPathMakeThread(CPath *path, int startfn, int pe);
998
999 void  CPathSend(int key, ...);
1000 void *CPathRecv(int key, ...);
1001 void  CPathReduce(int key, ...);
1002
1003 void CPathMsgDecodeBytes(void *msg, int *len, void *bytes);
1004 void CPathMsgDecodeReduction(void *msg,int *vecsize,int *eltsize,void *bytes);
1005 void CPathMsgFree(void *msg);
1006
1007 #define CPATH_ALL    (-1)
1008 #define CPATH_END      0
1009 #define CPATH_DEST     1
1010 #define CPATH_DESTELT  2
1011 #define CPATH_TAG      3
1012 #define CPATH_TAGS     4
1013 #define CPATH_TAGVEC   5
1014 #define CPATH_BYTES    6
1015 #define CPATH_OVER     7
1016 #define CPATH_REDUCER  8
1017 #define CPATH_REDBYTES 9
1018
1019 /******** CONVCONDS ********/
1020
1021 typedef void (*CcdVoidFn)(void *);
1022
1023 /*CPU conditions*/
1024 #define CcdPROCESSOR_BEGIN_BUSY 0
1025 #define CcdPROCESSOR_END_IDLE 0 /*Synonym*/
1026 #define CcdPROCESSOR_BEGIN_IDLE 1
1027 #define CcdPROCESSOR_END_BUSY 1 /*Synonym*/
1028 #define CcdPROCESSOR_STILL_IDLE 2
1029
1030 /*Periodic calls*/
1031 #define CcdPERIODIC       16 /*every few ms*/
1032 #define CcdPERIODIC_10ms  17 /*every 10ms (100Hz)*/
1033 #define CcdPERIODIC_100ms 18 /*every 100ms (10Hz)*/
1034 #define CcdPERIODIC_1second  19 /*every second*/
1035 #define CcdPERIODIC_1s       19 /*every second*/
1036 #define CcdPERIODIC_10second 20 /*every 10 seconds*/
1037 #define CcdPERIODIC_10seconds 20 /*every 10 seconds*/
1038 #define CcdPERIODIC_10s      20 /*every 10 seconds*/
1039 #define CcdPERIODIC_1minute  21 /*every minute*/
1040 #define CcdPERIODIC_10minute 22 /*every 10 minutes*/
1041 #define CcdPERIODIC_1hour    23 /*every hour*/
1042 #define CcdPERIODIC_12hour   24 /*every 12 hours*/
1043 #define CcdPERIODIC_1day     25 /*every day*/
1044
1045 /*Other conditions*/
1046 #define CcdQUIESCENCE 30
1047 #define CcdSIGUSR1 32+1
1048 #define CcdSIGUSR2 32+2
1049
1050 /*User-defined conditions start here*/
1051 #define CcdUSER    48
1052
1053 void CcdCallFnAfter(CcdVoidFn fnp, void *arg, unsigned int msecs);
1054 int CcdCallOnCondition(int condnum, CcdVoidFn fnp, void *arg);
1055 int CcdCallOnConditionKeep(int condnum, CcdVoidFn fnp, void *arg);
1056 void CcdCancelCallOnCondition(int condnum, int idx);
1057 void CcdCancelCallOnConditionKeep(int condnum, int idx);
1058 void CcdRaiseCondition(int condnum);
1059
1060 /* Command-Line-Argument handling */
1061 int CmiGetArgString(char **argv,const char *arg,char **optDest);
1062 int CmiGetArgInt(char **argv,const char *arg,int *optDest);
1063 int CmiGetArgFlag(char **argv,const char *arg);
1064 void CmiDeleteArgs(char **argv,int k);
1065 int CmiGetArgc(char **argv);
1066 char **CmiCopyArgs(char **argv);
1067
1068 #if CMK_CMIDELIVERS_USE_COMMON_CODE
1069 CpvExtern(void*, CmiLocalQueue);
1070 #endif
1071
1072 /*****************************************************************************
1073  *
1074  *    Converse Quiescence Detection
1075  *
1076  *****************************************************************************/
1077
1078 struct ConvQdMsg;
1079 struct ConvQdState;
1080 typedef struct ConvQdMsg    *CQdMsg;
1081 typedef struct ConvQdState  *CQdState;
1082 typedef CcdVoidFn CQdVoidFn; 
1083
1084 CpvExtern(CQdState, cQdState);
1085
1086 void CQdInit(void);
1087 void CQdCreate(CQdState, int);
1088 void CQdProcess(CQdState, int);
1089 int  CQdGetCreated(CQdState);
1090 int  CQdGetProcessed(CQdState);
1091 void CQdRegisterCallback(CQdVoidFn, void *);
1092 void CmiStartQD(CQdVoidFn, void *);
1093
1094 /*****************************************************************************
1095  *
1096  *    Converse Random Numbers
1097  *
1098  *****************************************************************************/
1099
1100 typedef struct rngen_
1101 {
1102   unsigned int prime;
1103   double state[3], multiplier[3];/* simulate 64 bit arithmetic */
1104 } CrnStream;
1105
1106 void CrnInitStream(CrnStream *, int, int);
1107 int CrnInt(CrnStream *);
1108 double CrnDouble(CrnStream *);
1109 float CrnFloat(CrnStream *);
1110 void CrnSrand(int);
1111 int CrnRand(void);
1112 double CrnDrand(void);
1113
1114 #include "conv-lists.h"
1115 #include "conv-trace.h"
1116
1117 /**** DEAL WITH DIFFERENCES: KERNIGHAN-RITCHIE-C, ANSI-C, AND C++ ****/
1118
1119 #if defined(__cplusplus)
1120 }
1121 #endif
1122
1123 #include "debug-conv.h"
1124
1125
1126 #endif /* CONVERSE_H */