Charm++: Charm Source Code Documentation

00001 
00031 #ifndef CONVERSE_H
00032 #define CONVERSE_H
00033 
00034 #define CMIALIGN(x,n)       (size_t)((~(n-1))&((x)+(n-1)))
00035 /*#define ALIGN8(x)        (size_t)((~7)&((x)+7)) */
00036 #define ALIGN8(x)          CMIALIGN(x,8)
00037 
00041 #include "conv-config.h"
00042 
00043 #if CMK_HAS_STDINT_H
00044 #include <stdint.h>
00045 #endif
00046 
00047 #include <stdio.h>
00048 #include <stdlib.h>
00049 
00050 /* Paste the tokens x and y together, without any space between them.
00051    The ANSI C way to do this is the bizarre ## "token-pasting" 
00052    preprocessor operator.
00053  */
00054 #define CMK_CONCAT(x,y) x##y
00055 /* Tag variable y as being from unit x: */
00056 #define CMK_TAG(x,y) x##y##_
00057 
00058 #include "pup_c.h"
00059 
00060 /* the following flags denote properties of the C compiler,  */
00061 /* not the C++ compiler.  If this is C++, ignore them.       */
00062 #ifdef __cplusplus
00063 
00064 /* Only C++ needs this backup bool defined.  We'll assume that C doesn't
00065    use it */
00066 
00067 #if ! CMK_BOOL_DEFINED
00068 enum CmiBool {CmiFalse=0, CmiTrue=1};
00069 typedef enum {false = 0, true = 1} bool;
00070 #else
00071 typedef bool CmiBool;
00072 #define CmiFalse false
00073 #define CmiTrue true
00074 #endif
00075 
00076 #if ! CMK_HAS_OFFSETOF
00077 #undef offsetof
00078 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
00079 #else
00080 #include <stddef.h>
00081 #endif
00082 
00083 extern "C" {
00084 #endif
00085 
00086 /* Global variables used by charmdebug to maintain information */
00087 extern void CpdSetInitializeMemory(int v);
00088 extern void CpdSystemEnter();
00089 extern void CpdSystemExit();
00090 #if CMK_ERROR_CHECKING
00091 extern int memory_status_info;
00092 extern int memory_chare_id;
00093 #define setMemoryStatus(p) { \
00094   int tmp = memory_status_info; \
00095   memory_status_info = p; \
00096   p = tmp; \
00097 }
00098 int setMemoryChareIDFromPtr(void *p);
00099 void setMemoryChareID(int id);
00100 void setMemoryOwnedBy(void *p, int id);
00101 #else
00102 #define setMemoryStatus(p) /* empty */
00103 #define setMemoryChareIDFromPtr(p) /* empty */
00104 #define setMemoryChareID(p) /* empty */
00105 #define setMemoryOwnedBy(p, id) /* empty */
00106 #endif
00107 
00108 /******************************************************************************
00109  *
00110  * Deal with Shared Memory
00111  *
00112  * Shared memory strongly affects how CPV, CSV, and CmiMyPe are defined,
00113  * and how memory locking is performed. Therefore, we control all these
00114  * functions with a single flag.
00115  *
00116  *****************************************************************************/
00117 
00118 #ifdef __cplusplus
00119 /* In C++, use new so t's constructor gets called */
00120 # define CpvInit_Alloc(t,n) new t[n]
00121 # define CpvInit_Alloc_scalar(t) new t
00122 #else
00123 # define CpvInit_Alloc(t,n) (t *)calloc(n,sizeof(t))
00124 # define CpvInit_Alloc_scalar(t) (t *)calloc(1,sizeof(t))
00125 #endif
00126 
00127 extern int CmiMyRank_();
00128 
00129 #if CMK_SHARED_VARS_UNAVAILABLE /* Non-SMP version of shared vars. */
00130 extern int _Cmi_mype;
00131 extern int _Cmi_numpes;
00132 extern int _Cmi_myrank; /* Normally zero; only 1 during SIGIO handling */
00133 extern int _Cmi_mynode;
00134 extern int _Cmi_numnodes;
00135 
00136 #define CmiMyPe()           _Cmi_mype
00137 #define CmiMyRank()         0
00138 #define CmiNumPes()         _Cmi_numpes
00139 #define CmiMyNodeSize()     1
00140 #define CmiMyNode()         _Cmi_mype
00141 #define CmiNumNodes()       _Cmi_numpes
00142 #define CmiNodeFirst(node)  (node)
00143 #define CmiNodeSize(node)   1
00144 #define CmiNodeOf(pe)       (pe)
00145 #define CmiRankOf(pe)       0
00146 
00147 #define CpvDeclare(t,v) t CMK_TAG(Cpv_,v)[2]
00148 #define CpvExtern(t,v)  extern t CMK_TAG(Cpv_,v)[2]
00149 #ifdef __cplusplus
00150 #define CpvCExtern(t,v)    extern "C" t CMK_TAG(Cpv_,v)[2]
00151 #else
00152 #define CpvCExtern(t,v)    CpvExtern(t,v)
00153 #endif
00154 #define CpvStaticDeclare(t,v) static t CMK_TAG(Cpv_,v)[2]
00155 #define CpvInitialize(t,v) do {} while(0)
00156 #define CpvInitialized(v) 1
00157 #define CpvAccess(v) CMK_TAG(Cpv_,v)[_Cmi_myrank]
00158 #define CpvAccessOther(v, r) CMK_TAG(Cpv_,v)[r]
00159 
00160 extern void CmiMemLock();
00161 extern void CmiMemUnlock();
00162 #define CmiNodeBarrier() /*empty*/
00163 #define CmiNodeAllBarrier() /*empty*/
00164 #define CmiSvAlloc CmiAlloc
00165 
00166 typedef int CmiNodeLock;
00167 #define CmiCreateLock() (0)
00168 #define CmiLock(lock) {(lock)++;}
00169 #define CmiUnlock(lock)  {(lock)--;}
00170 #define CmiTryLock(lock)  ((lock)?1:((lock)=1,0))
00171 #define CmiDestroyLock(lock) /*empty*/
00172 
00173 #endif
00174 
00175 #if CMK_SHARED_VARS_POSIX_THREADS_SMP /*Used by the net-*-smp versions*/
00176 
00177 #include <pthread.h>
00178 #include <sched.h>
00179 #ifdef CMK_FAKE_SCHED_YIELD
00180 #include <unistd.h>
00181 #define sched_yield() sleep(0)
00182 #endif
00183 
00184 extern int _Cmi_numpes;
00185 extern int _Cmi_mynodesize;
00186 extern int _Cmi_mynode;
00187 extern int _Cmi_numnodes;
00188 extern int _Cmi_noprocforcommthread;
00189 
00190 extern int CmiMyPe();
00191 extern int CmiMyRank();
00192 #define CmiNumPes()         _Cmi_numpes
00193 #define CmiMyNodeSize()     _Cmi_mynodesize
00194 #define CmiMyNode()         _Cmi_mynode
00195 #define CmiNumNodes()       _Cmi_numnodes
00196 extern int CmiNodeFirst(int node);
00197 extern int CmiNodeSize(int node);
00198 extern int CmiNodeOf(int pe);
00199 extern int CmiRankOf(int pe);
00200 
00201 #define CMK_CPV_IS_SMP sched_yield();
00202 
00203 extern void CmiNodeBarrier(void);
00204 extern void CmiNodeAllBarrier(void);
00205 #define CmiSvAlloc CmiAlloc
00206 
00207 #if CMK_HAS_SPINLOCK && CMK_USE_SPINLOCK
00208 typedef pthread_spinlock_t *CmiNodeLock;
00209 #define CmiLock(lock) (pthread_spin_lock(lock))
00210 #define CmiUnlock(lock) (pthread_spin_unlock(lock))
00211 #define CmiTryLock(lock) (pthread_spin_trylock(lock))
00212 #else
00213 typedef pthread_mutex_t *CmiNodeLock;
00214 #define CmiLock(lock) (pthread_mutex_lock(lock))
00215 #define CmiUnlock(lock) (pthread_mutex_unlock(lock))
00216 #define CmiTryLock(lock) (pthread_mutex_trylock(lock))
00217 #endif
00218 extern CmiNodeLock CmiCreateLock();
00219 extern void CmiDestroyLock(CmiNodeLock lock);
00220 
00221 extern CmiNodeLock CmiMemLock_lock;
00222 #define CmiMemLock() do{if (CmiMemLock_lock) CmiLock(CmiMemLock_lock);} while (0)
00223 
00224 #define CmiMemUnlock() do{if (CmiMemLock_lock) CmiUnlock(CmiMemLock_lock);} while (0)
00225 
00226 
00227 #endif
00228 
00229 #include "string.h"
00230 
00231 #if CMK_BLUEGENEL || CMK_BLUEGENEP
00232 #include "cmimemcpy.h"
00233 #else
00234 #define CmiMemcpy(dest, src, size) memcpy((dest), (src), (size))
00235 #endif
00236 
00237 #if CMK_SHARED_VARS_UNIPROCESSOR /*Used only by uth- and sim- versions*/
00238 
00239 extern int _Cmi_mype;
00240 extern int _Cmi_numpes;
00241 
00242 #define CmiMyPe()              _Cmi_mype
00243 #define CmiMyRank()            _Cmi_mype
00244 #define CmiNumPes()            _Cmi_numpes
00245 #define CmiMyNodeSize()        _Cmi_numpes
00246 #define CmiMyNode()            0
00247 #define CmiNumNodes()          1
00248 #define CmiNodeFirst(node)     0
00249 #define CmiNodeSize(node)      _Cmi_numpes
00250 #define CmiNodeOf(pe)          0
00251 #define CmiRankOf(pe)          (pe)
00252 
00253 #define CpvDeclare(t,v) t* CMK_TAG(Cpv_,v)
00254 #define CpvExtern(t,v)  extern t* CMK_TAG(Cpv_,v)
00255 #ifdef __cplusplus
00256 #define CpvCExtern(t,v)  extern "C" t* CMK_TAG(Cpv_,v)
00257 #else
00258 #define CpvCExtern(t,v)    CpvExtern(t,v)
00259 #endif
00260 #define CpvStaticDeclare(t,v) static t* CMK_TAG(Cpv_,v)
00261 #define CpvInitialize(t,v)\
00262   do  { if (CMK_TAG(Cpv_,v)==0)\
00263         { CMK_TAG(Cpv_,v) = CpvInit_Alloc(t,CmiNumPes()); }}\
00264   while(0)
00265 #define CpvInitialized(v) (0!=CMK_TAG(Cpv_,v))
00266 #define CpvAccess(v) CMK_TAG(Cpv_,v)[CmiMyPe()]
00267 #define CpvAccessOther(v, r) CMK_TAG(Cpv_,v)[r]
00268 
00269 #define CmiMemLock() 0
00270 #define CmiMemUnlock() 0
00271 extern void CmiNodeBarrier();
00272 extern void CmiNodeAllBarrier();
00273 #define CmiSvAlloc CmiAlloc
00274 
00275 typedef int *CmiNodeLock;
00276 extern CmiNodeLock  CmiCreateLock(void);
00277 extern void         CmiLock(CmiNodeLock lock);
00278 extern void         CmiUnlock(CmiNodeLock lock);
00279 extern int          CmiTryLock(CmiNodeLock lock);
00280 extern void         CmiDestroyLock(CmiNodeLock lock);
00281 
00282 #endif
00283 
00284 #if CMK_SHARED_VARS_PTHREADS /*Used only by origin-pthreads*/
00285 
00286 #include <pthread.h>
00287 #include <sched.h>
00288 
00289 extern int CmiMyPe();
00290 extern int _Cmi_numpes;
00291 
00292 #define CmiNumPes()            _Cmi_numpes
00293 #define CmiMyRank()            CmiMyPe()
00294 #define CmiMyNodeSize()        _Cmi_numpes
00295 #define CmiMyNode()            0
00296 #define CmiNumNodes()          1
00297 #define CmiNodeFirst(node)     0
00298 #define CmiNodeSize(node)      _Cmi_numpes
00299 #define CmiNodeOf(pe)          0
00300 #define CmiRankOf(pe)          (pe)
00301 
00302 #define CMK_CPV_IS_SMP sched_yield();
00303 
00304 extern void CmiMemLock();
00305 extern void CmiMemUnlock();
00306 extern void CmiNodeBarrier();
00307 extern void CmiNodeAllBarrier();
00308 #define CmiSvAlloc CmiAlloc
00309 
00310 typedef pthread_mutex_t *CmiNodeLock;
00311 extern CmiNodeLock  CmiCreateLock(void);
00312 extern void         CmiLock(CmiNodeLock lock);
00313 extern void         CmiUnlock(CmiNodeLock lock);
00314 extern int          CmiTryLock(CmiNodeLock lock);
00315 extern void         CmiDestroyLock(CmiNodeLock lock);
00316 
00317 #endif
00318 
00319 #if CMK_SHARED_VARS_NT_THREADS /*Used only by win32 versions*/
00320 
00321 #include <windows.h>
00322 
00323 extern int _Cmi_numpes;
00324 extern int _Cmi_mynodesize;
00325 extern int _Cmi_mynode;
00326 extern int _Cmi_numnodes;
00327 extern int _Cmi_noprocforcommthread;
00328 
00329 extern int CmiMyPe();
00330 extern int CmiMyRank();
00331 #define CmiNumPes()         _Cmi_numpes
00332 #define CmiMyNodeSize()     _Cmi_mynodesize
00333 #define CmiMyNode()         _Cmi_mynode
00334 #define CmiNumNodes()       _Cmi_numnodes
00335 extern int CmiNodeFirst(int node);
00336 extern int CmiNodeSize(int node);
00337 extern int CmiNodeOf(int pe);
00338 extern int CmiRankOf(int pe);
00339 
00340 #define CMK_CPV_IS_SMP Sleep(0);
00341 
00342 extern void CmiNodeBarrier(void);
00343 extern void CmiNodeAllBarrier(void);
00344 #define CmiSvAlloc CmiAlloc
00345 
00346 typedef HANDLE CmiNodeLock;
00347 extern  CmiNodeLock CmiCreateLock(void);
00348 #define CmiLock(lock) (WaitForSingleObject(lock, INFINITE))
00349 #define CmiUnlock(lock) (ReleaseMutex(lock))
00350 #define CmiTryLock(lock) (WaitForSingleObject(lock, 0))
00351 extern  void CmiDestroyLock(CmiNodeLock lock);
00352 
00353 extern CmiNodeLock CmiMemLock_lock;
00354 #define CmiMemLock() do{if (CmiMemLock_lock) CmiLock(CmiMemLock_lock);} while (0)
00355 #define CmiMemUnlock() do{if (CmiMemLock_lock) CmiUnlock(CmiMemLock_lock);} while (0)
00356 
00357 #endif
00358 
00359 #if CMK_SHARED_VARS_UNAVAILABLE   /* non-SMP version */
00360 
00361 typedef int CmiImmediateLockType;
00362 extern int _immediateLock;
00363 extern int _immediateFlag;
00364 #define CmiCreateImmediateLock() (0)
00365 #define CmiImmediateLock(ignored) { _immediateLock++; }
00366 #if CMK_IMMEDIATE_MSG
00367 #define CmiImmediateUnlock(ignored) \
00368   { _immediateLock--; \
00369     if(_immediateFlag) \
00370       CmiProbeImmediateMsg(); } 
00371 #else
00372 #define CmiImmediateUnlock(ignored) { _immediateLock--; }
00373 #endif
00374 #define CmiCheckImmediateLock(ignored) \
00375   ((_immediateLock)?((_immediateFlag=1),1):0)
00376 #define CmiClearImmediateFlag() { _immediateFlag=0; }
00377 
00378 #else /* SMP and all other weird versions */
00379 
00380 typedef CmiNodeLock CmiImmediateLockType;
00381 #define CmiCreateImmediateLock() CmiCreateLock()
00382 #define CmiImmediateLock(immediateLock) CmiLock((immediateLock))
00383 #define CmiImmediateUnlock(immediateLock) CmiUnlock((immediateLock)) 
00384 #define CmiCheckImmediateLock(ignored)  (0)
00385 #define CmiClearImmediateFlag() 
00386 
00387 #endif
00388 
00389 /* This is the default Cpv implmentation for SMP-style systems:
00390 A Cpv variable is actually a pointer to an array of values, one
00391 for each processor in the node.
00392 */
00393 #ifdef CMK_CPV_IS_SMP
00394 
00395 /* buggy xlc compiler on bluegene/p does not like memory fence in Cpvs */
00396 #if CMK_BLUEGENEP && ( defined(__xlC__) || defined(__xlc__) )
00397 #define CpvMemoryReadFence()
00398 #define CpvMemoryWriteFence()
00399 #else
00400 #define CpvMemoryReadFence() CmiMemoryReadFence()
00401 #define CpvMemoryWriteFence() CmiMemoryWriteFence()
00402 #endif
00403 
00404 #if CMK_HAS_TLS_VARIABLES && !CMK_NOT_USE_TLS_THREAD
00405 #define CpvDeclare(t,v) __thread t* CMK_TAG(Cpv_,v) = NULL;   \
00406                         int CMK_TAG(Cpv_inited_,v) = 0;  \
00407                         t ** CMK_TAG(Cpv_addr_,v);
00408 #define CpvExtern(t,v)  extern __thread t* CMK_TAG(Cpv_,v);  \
00409                         extern int CMK_TAG(Cpv_inited_,v);  \
00410                         extern t ** CMK_TAG(Cpv_addr_,v)
00411 #ifdef __cplusplus
00412 #define CpvCExtern(t,v) extern "C"  __thread t* CMK_TAG(Cpv_,v);  \
00413                         extern "C" int CMK_TAG(Cpv_inited_,v);  \
00414                         extern "C" t ** CMK_TAG(Cpv_addr_,v)
00415 #else
00416 #define CpvCExtern(t,v)    CpvExtern(t,v)
00417 #endif
00418 #define CpvStaticDeclare(t,v) static __thread t* CMK_TAG(Cpv_,v) = NULL;   \
00419                         static int CMK_TAG(Cpv_inited_,v) = 0;  \
00420                         static t ** CMK_TAG(Cpv_addr_,v)
00421 #define CpvInitialize(t,v)\
00422     do { \
00423        if (CmiMyRank()) { \
00424                /*while (!CpvInitialized(v)) CMK_CPV_IS_SMP;*/\
00425                CpvMemoryReadFence(); \
00426                while (CMK_TAG(Cpv_inited_,v)==0) { CMK_CPV_IS_SMP; CpvMemoryReadFence(); } \
00427                CMK_TAG(Cpv_,v)=CpvInit_Alloc_scalar(t); \
00428                CMK_TAG(Cpv_addr_,v)[CmiMyRank()] = CMK_TAG(Cpv_,v); \
00429        } else { \
00430                CMK_TAG(Cpv_,v)=CpvInit_Alloc_scalar(t); \
00431                CMK_TAG(Cpv_addr_,v)=CpvInit_Alloc(t*, 1+CmiMyNodeSize()); \
00432                CMK_TAG(Cpv_addr_,v)[CmiMyRank()] = CMK_TAG(Cpv_,v); \
00433                CpvMemoryWriteFence();   \
00434                CMK_TAG(Cpv_inited_,v)=1; \
00435        } \
00436     } while(0)
00437 #define CpvInitialized(v) (0!=CMK_TAG(Cpv_,v))
00438 #define CpvAccess(v) (*CMK_TAG(Cpv_,v))
00439 #define CpvAccessOther(v, r) (*(CMK_TAG(Cpv_addr_,v)[r]))
00440 
00441 #else
00442 
00443 #define CpvDeclare(t,v) t* CMK_TAG(Cpv_,v)
00444 #define CpvExtern(t,v)  extern t* CMK_TAG(Cpv_,v)
00445 #ifdef __cplusplus
00446 #define CpvCExtern(t,v)    extern "C" t* CMK_TAG(Cpv_,v)
00447 #else
00448 #define CpvCExtern(t,v)    CpvExtern(t,v)
00449 #endif
00450 #define CpvStaticDeclare(t,v) static t* CMK_TAG(Cpv_,v)
00451 #define CpvInitialize(t,v)\
00452     do { \
00453        if (CmiMyRank()) { \
00454                CpvMemoryReadFence(); \
00455                        while (!CpvInitialized(v)) { CMK_CPV_IS_SMP ; CpvMemoryReadFence(); } \
00456        } else { \
00457                t* tmp = CpvInit_Alloc(t,1+CmiMyNodeSize());\
00458                CpvMemoryWriteFence();   \
00459                CMK_TAG(Cpv_,v)=tmp;   \
00460                /* CMK_TAG(Cpv_,v)=CpvInit_Alloc(t,1+CmiMyNodeSize()); */\
00461        } \
00462     } while(0)
00463 #define CpvInitialized(v) (0!=CMK_TAG(Cpv_,v))
00464 #define CpvAccess(v) CMK_TAG(Cpv_,v)[CmiMyRank()]
00465 #define CpvAccessOther(v, r) CMK_TAG(Cpv_,v)[r]
00466 #endif
00467 
00468 #endif
00469 
00470 /*Csv are the same almost everywhere:*/
00471 #ifndef CsvDeclare
00472 #define CsvDeclare(t,v) t CMK_TAG(Csv_,v)
00473 #define CsvStaticDeclare(t,v) static t CMK_TAG(Csv_,v)
00474 #define CsvExtern(t,v) extern t CMK_TAG(Csv_,v)
00475 #define CsvInitialize(t,v) do{}while(0)
00476 #define CsvAccess(v) CMK_TAG(Csv_,v)
00477 #endif
00478 
00479 extern CmiNodeLock _smp_mutex;
00480 
00481 extern int CmiBarrier(void);
00482 extern int CmiBarrierZero(void);
00483 
00484 /* cpu topology */
00485 extern int CmiNumCores(void);
00486 extern int CmiCpuTopologyEnabled();
00487 extern int CmiPeOnSamePhysicalNode(int pe1, int pe2);
00488 extern int CmiNumPhysicalNodes();
00489 extern int CmiPhysicalNodeID(int pe);
00490 extern int CmiNumPesOnPhysicalNode(int node);
00491 extern void CmiGetPesOnPhysicalNode(int node, int **pelist, int *num);
00492 extern int CmiGetFirstPeOnPhysicalNode(int node);
00493 extern int CmiPhysicalRank(int pe);
00494 
00495 extern int CmiPrintCPUAffinity();
00496 extern int CmiSetCPUAffinity(int core);
00497 extern int CmiOnCore();
00498 
00501 int CmiLongSendQueue(int forNode,int longerThanBytes);
00502 
00503 /******** CMI: TYPE DEFINITIONS ********/
00504 
00505 typedef CMK_TYPEDEF_INT2      CmiInt2;
00506 typedef CMK_TYPEDEF_INT4      CmiInt4;
00507 typedef CMK_TYPEDEF_INT8      CmiInt8;
00508 typedef CMK_TYPEDEF_UINT2     CmiUInt2;
00509 typedef CMK_TYPEDEF_UINT4     CmiUInt4;
00510 typedef CMK_TYPEDEF_UINT8     CmiUInt8;
00511 typedef CMK_TYPEDEF_FLOAT4    CmiFloat4;
00512 typedef CMK_TYPEDEF_FLOAT8    CmiFloat8;
00513 
00514 #if CMK_SIZET_64BIT
00515 typedef CmiUInt8     CmiIntPtr;
00516 #else
00517 typedef CmiUInt4     CmiIntPtr;
00518 #endif
00519 
00520 
00521 typedef void  *CmiCommHandle;
00522 typedef void (*CmiHandler)(void *msg);
00523 typedef void (*CmiHandlerEx)(void *msg,void *userPtr);
00524 
00525 typedef struct CMK_MSG_HEADER_BASIC CmiMsgHeaderBasic;
00526 typedef struct CMK_MSG_HEADER_EXT   CmiMsgHeaderExt;
00527 
00528 #define CmiMsgHeaderSizeBytes (sizeof(CmiMsgHeaderBasic))
00529 #define CmiExtHeaderSizeBytes (sizeof(CmiMsgHeaderExt))
00530 
00531 /* all common extra fields in BigSim message header */
00532 #define CMK_BIGSIM_FIELDS  CmiInt4 nd,n; double rt; CmiInt2 tID, hID; char t, flag; CmiInt2 ref; CmiInt4 msgID, srcPe;
00533 
00534 #ifndef CmiReservedHeaderSize
00535 typedef struct CMK_MSG_HEADER_BIGSIM_   CmiBlueGeneMsgHeader;
00536 #define CmiBlueGeneMsgHeaderSizeBytes (sizeof(CmiBlueGeneMsgHeader))
00537 #if CMK_BIGSIM_CHARM
00538 #  define CmiReservedHeaderSize   CmiBlueGeneMsgHeaderSizeBytes
00539 #else
00540 #  define CmiReservedHeaderSize   CmiExtHeaderSizeBytes
00541 #endif
00542 #endif
00543 
00544 /******** CMI, CSD: MANY LOW-LEVEL OPERATIONS ********/
00545 
00546 typedef struct {
00547         CmiHandlerEx hdlr;
00548         void *userPtr;
00549 } CmiHandlerInfo;
00550 
00551 CpvExtern(CmiHandlerInfo*, CmiHandlerTable);
00552 CpvExtern(int,         CmiHandlerMax);
00553 CpvExtern(void*,       CsdSchedQueue);
00554 #if CMK_GRID_QUEUE_AVAILABLE
00555 CpvExtern(void *,      CsdGridQueue);
00556 #endif
00557 #if CMK_OBJECT_QUEUE_AVAILABLE
00558 CpvExtern(void*,       CsdObjQueue);
00559 #endif
00560 #if CMK_NODE_QUEUE_AVAILABLE
00561 CsvExtern(void*,       CsdNodeQueue);
00562 CsvExtern(CmiNodeLock, CsdNodeQueueLock);
00563 #endif
00564 CpvExtern(int,         CsdStopFlag);
00565 CpvExtern(int,         CsdLocalCount);
00566 #define CSD_LOCAL_MAX_DEFAULT 0
00567 
00568 extern int CmiRegisterHandler(CmiHandler h);
00569 extern int CmiRegisterHandlerEx(CmiHandlerEx h,void *userPtr);
00570 #if CMI_LOCAL_GLOBAL_AVAILABLE
00571 extern int CmiRegisterHandlerLocal(CmiHandler);
00572 extern int CmiRegisterHandlerGlobal(CmiHandler);
00573 #endif
00574 extern void CmiNumberHandler(int n, CmiHandler h);
00575 extern void CmiNumberHandlerEx(int n, CmiHandlerEx h,void *userPtr);
00576 
00577 #define CmiGetHandler(m)  (((CmiMsgHeaderExt*)m)->hdl)
00578 #define CmiGetXHandler(m) (((CmiMsgHeaderExt*)m)->xhdl)
00579 #define CmiGetInfo(m)     (((CmiMsgHeaderExt*)m)->info)
00580 #define CmiGetRoot(m)     (((CmiMsgHeaderExt*)m)->root)
00581 #define CmiGetRedID(m)    (((CmiMsgHeaderExt*)m)->redID)
00582 #define CmiGetStrategy(m) (((CmiMsgHeaderExt*)m)->stratid)
00583 
00584 #define CmiSetHandler(m,v)  do {((((CmiMsgHeaderExt*)m)->hdl)=(v));} while(0)
00585 #define CmiSetXHandler(m,v) do {((((CmiMsgHeaderExt*)m)->xhdl)=(v));} while(0)
00586 #define CmiSetInfo(m,v)     do {((((CmiMsgHeaderExt*)m)->info)=(v));} while(0)
00587 #define CmiSetRoot(m,v)     do {((((CmiMsgHeaderExt*)m)->root)=(v));} while(0)
00588 #define CmiSetRedID(m,v)    do {((((CmiMsgHeaderExt*)m)->redID)=(v));} while(0)
00589 #define CmiSetStrategy(m,v) do {((((CmiMsgHeaderExt*)m)->stratid)=(v);} while(0)
00590 
00591 #define CmiHandlerToInfo(n) (CpvAccess(CmiHandlerTable)[n])
00592 #define CmiHandlerToFunction(n) (CmiHandlerToInfo(n).hdlr)
00593 #define CmiGetHandlerInfo(env) (CmiHandlerToInfo(CmiGetHandler(env)))
00594 #define CmiGetHandlerFunction(env) (CmiHandlerToFunction(CmiGetHandler(env)))
00595 
00596 #if __FAULT__
00597 CpvExtern(int, _curRestartPhase);      /* number of restarts */
00598 #endif
00599 
00600 #if CMK_MEM_CHECKPOINT
00601 #undef CmiSetHandler
00602 #define CmiSetHandler(m,v)  do {(((CmiMsgHeaderExt*)m)->hdl)=(v); (((CmiMsgHeaderExt*)m)->pn)=CpvAccess(_curRestartPhase);} while(0)
00603 #define MESSAGE_PHASE_CHECK(msg)        \
00604         {       \
00605           int phase = CmiGetRestartPhase(msg);  \
00606           if (phase != 9999 && phase < CpvAccess(_curRestartPhase)) {   \
00607             /* CmiPrintf("[%d] discard message of phase %d cur_restart_phase:%d. \n", CmiMyPe(), phase, cur_restart_phase); */  \
00608             CmiFree(msg);       \
00609             return;     \
00610           }     \
00611           /* CmiAssert(phase == cur_restart_phase || phase == 9999); */ \
00612           if (phase > CpvAccess(_curRestartPhase) && phase != 9999) {    \
00613             /* CmiPrintf("[%d] enqueue message of phase %d cur_restart_phase:%d. \n", CmiMyPe(), phase, cur_restart_phase); */  \
00614             CsdEnqueueFifo(msg);    \
00615             return;     \
00616           }     \
00617         }
00618 #else
00619 #define MESSAGE_PHASE_CHECK(msg)
00620 #endif
00621 
00625 typedef struct {
00626   int size;
00627   int ref;
00628 } CmiChunkHeader;
00629 
00630 #if CMK_USE_IBVERBS | CMK_USE_IBUD
00631 struct infiCmiChunkMetaDataStruct;
00632 
00633 typedef struct infiCmiChunkHeaderStruct{
00634   struct infiCmiChunkMetaDataStruct *metaData;
00635         CmiChunkHeader chunkHeader;
00636 } infiCmiChunkHeader;
00637 
00638 struct infiCmiChunkMetaDataStruct *registerMultiSendMesg(char *msg,int msgSize);
00639 #endif
00640 
00641 /* Given a user chunk m, extract the enclosing chunk header fields: */
00642 #define SIZEFIELD(m) (((CmiChunkHeader *)(m))[-1].size)
00643 #define REFFIELD(m) (((CmiChunkHeader *)(m))[-1].ref)
00644 #define BLKSTART(m) (((CmiChunkHeader *)(m))-1)
00645 
00646 extern void* malloc_nomigrate(size_t size);
00647 
00657 void    *CmiAlloc(int size);
00658 void     CmiReference(void *blk);
00659 int      CmiGetReference(void *blk);
00660 int      CmiSize(void *blk);
00661 void     CmiFree(void *blk);
00662 
00663 #ifndef CMI_TMP_SKIP
00664 void *CmiTmpAlloc(int size);
00665 void CmiTmpFree(void *);
00666 #endif
00667 
00668 /* Pool features */
00669 
00670 
00671 /* Various special features of certain -memory modes: */
00672 extern void * memory_stack_top; /* contains the top of the stack, for -memory charmdebug */
00673 void CmiMemoryCheck(void); /* heap check, for -memory paranoid */
00674 void CmiMemoryMark(void); /* ignore current allocations, for -memory leak */
00675 void CmiMemoryMarkBlock(void *blk); /* ignore this allocation, for -memory leak */
00676 void CmiMemorySweep(const char *where); /* print current allocations, for -memory leak */
00677 CMK_TYPEDEF_UINT8 CmiMemoryUsage();
00678 CMK_TYPEDEF_UINT8 CmiMaxMemoryUsage();
00679 void CmiResetMaxMemory();
00680 CMK_TYPEDEF_UINT8 CmiMinMemoryUsage();
00681 void CmiResetMinMemory();
00682 
00683 /* General functions for malloc'ing aligned buffers */
00684 #define CmiRoundUpToPow2(s, p2)  (s + ((p2 - (s & (p2 - 1))) & (p2 - 1)))
00685 void* CmiMallocAligned(const size_t size, const unsigned int alignment);
00686 void CmiFreeAligned(void* ptr);
00687 
00688 #define CMI_MEMORY_IS_ISOMALLOC   (1<<1)
00689 #define CMI_MEMORY_IS_PARANOID    (1<<2)
00690 #define CMI_MEMORY_IS_GNU         (1<<3)
00691 #define CMI_MEMORY_IS_GNUOLD      (1<<4)
00692 #define CMI_MEMORY_IS_OS          (1<<5)
00693 #define CMI_MEMORY_IS_CHARMDEBUG  (1<<6)
00694 int CmiMemoryIs(int flag); /* return state of this flag */
00695 
00696 #define CMI_THREAD_IS_QT         (1<<1)
00697 #define CMI_THREAD_IS_CONTEXT    (1<<2)
00698 #define CMI_THREAD_IS_UJCONTEXT  (1<<3)
00699 #define CMI_THREAD_IS_PTHREADS   (1<<4)
00700 #define CMI_THREAD_IS_FIBERS     (1<<5)
00701 #define CMI_THREAD_IS_ALIAS      (1<<6)
00702 #define CMI_THREAD_IS_STACKCOPY  (1<<7)
00703 #define CMI_THREAD_IS_TLS        (1<<8)
00704 int CmiThreadIs(int flag); /* return state of this flag */
00705 
00706 void CmiMkdir(const char *dirName);
00707 
00708 double   CmiCpuTimer(void);
00709 
00710 #if CMK_TIMER_USE_RDTSC 
00711 #ifndef __x86_64__
00712 # if ! (CMK_GCC_X86_ASM || CMK_GCC_IA64_ASM)
00713 /* Can't use rdtsc unless we have x86 or ia64 assembly: */
00714 #  undef CMK_TIMER_USE_RDTSC
00715 #  undef CMK_TIMER_USE_GETRUSAGE
00716 #  define CMK_TIMER_USE_RDTSC 0
00717 #  define CMK_TIMER_USE_GETRUSAGE 1
00718 # endif
00719 #endif
00720 #endif
00721 
00722 #if CMK_TIMER_USE_RDTSC 
00723 extern double _cpu_speed_factor;
00724 
00725 static __inline__ unsigned long long int rdtsc(void)
00726 {
00727         unsigned long long int x;
00728 #ifdef __x86_64__
00729         /* taken from papi code ("perfctr-p3.c") for machines like opteron */
00730         do {
00731           unsigned int a,d;
00732           asm volatile("rdtsc" : "=a" (a), "=d" (d));
00733           (x) = ((unsigned long)a) | (((unsigned long)d)<<32);
00734         } while(0);
00735 #elif CMK_GCC_IA64_ASM
00736         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
00737 #elif CMK_GCC_X86_ASM
00738         __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
00739 #else
00740 #  error "Unknown assembly format-- can't use CMK_TIMER_USE_RDTSC."
00741 #endif
00742         return x;
00743 }
00744 
00745 #define CmiWallTimer() ((double)rdtsc()*(_cpu_speed_factor))
00746 #define CmiTimer CmiCpuTimer
00747 double   CmiStartTimer(void);
00748 double   CmiInitTime(void);
00749 #define CmiTimerIsSynchronized()        (0)
00750 #define CmiTimerAbsolute()              (0)
00751 
00752 #else
00753 void     CmiTimerInit(char **argv);
00754 int      CmiTimerAbsolute();
00755 double   CmiStartTimer(void);
00756 double   CmiInitTime(void);
00757 double   CmiTimer(void);
00758 double   CmiWallTimer(void);
00759 int      CmiTimerIsSynchronized();
00760 #endif
00761 
00762 char *CmiPrintDate();
00763 
00764 #include "queueing.h" /* for "Queue" */
00765 
00766 #if CMK_NODE_QUEUE_AVAILABLE
00767 
00768 #define CsdNodeEnqueueGeneral(x,s,i,p) do { \
00769           CmiLock(CsvAccess(CsdNodeQueueLock));\
00770           CqsEnqueueGeneral((Queue)CsvAccess(CsdNodeQueue),(x),(s),(i),(p)); \
00771           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
00772         } while(0)
00773 #define CsdNodeEnqueueFifo(x)     do { \
00774           CmiLock(CsvAccess(CsdNodeQueueLock));\
00775           CqsEnqueueFifo((Queue)CsvAccess(CsdNodeQueue),(x)); \
00776           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
00777         } while(0)
00778 #define CsdNodeEnqueueLifo(x)     do { \
00779           CmiLock(CsvAccess(CsdNodeQueueLock));\
00780           CqsEnqueueLifo((Queue)CsvAccess(CsdNodeQueue),(x))); \
00781           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
00782         } while(0)
00783 #define CsdNodeEnqueue(x)     do { \
00784           CmiLock(CsvAccess(CsdNodeQueueLock));\
00785           CqsEnqueueFifo((Queue)CsvAccess(CsdNodeQueue),(x));\
00786           CmiUnlock(CsvAccess(CsdNodeQueueLock)); \
00787         } while(0)
00788 
00789 #define CsdNodeEmpty()            (CqsEmpty(C(Queue)pvAccess(CsdNodeQueue)))
00790 #define CsdNodeLength()           (CqsLength((Queue)CpvAccess(CsdNodeQueue)))
00791 
00792 #else
00793 
00794 #define CsdNodeEnqueueGeneral(x,s,i,p) (CsdEnqueueGeneral(x,s,i,p))
00795 #define CsdNodeEnqueueFifo(x) (CqsEnqueueFifo((Queue)CpvAccess(CsdSchedQueue),(x)))
00796 #define CsdNodeEnqueueLifo(x) (CqsEnqueueLifo((Queue)CpvAccess(CsdSchedQueue),(x)))
00797 #define CsdNodeEnqueue(x)     (CsdEnqueue(x))
00798 #define CsdNodeEmpty()        (CqsEmpty((Queue)CpvAccess(CsdSchedQueue)))
00799 #define CsdNodeLength()       (CqsLength((Queue)CpvAccess(CsdSchedQueue)))
00800 
00801 #endif
00802 
00803 #define CsdEnqueueGeneral(x,s,i,p)\
00804     (CqsEnqueueGeneral((Queue)CpvAccess(CsdSchedQueue),(x),(s),(i),(p)))
00805 #define CsdEnqueueFifo(x)     (CqsEnqueueFifo((Queue)CpvAccess(CsdSchedQueue),(x)))
00806 #define CsdEnqueueLifo(x)     (CqsEnqueueLifo((Queue)CpvAccess(CsdSchedQueue),(x)))
00807 #define CsdEnqueue(x)         (CqsEnqueueFifo((Queue)CpvAccess(CsdSchedQueue),(x)))
00808 #define CsdEmpty()            (CqsEmpty((Queue)CpvAccess(CsdSchedQueue)))
00809 #define CsdLength()           (CqsLength((Queue)CpvAccess(CsdSchedQueue)))
00810 
00811 #if CMK_CMIPRINTF_IS_A_BUILTIN /* these are implemented in machine.c */
00812 void  CmiPrintf(const char *, ...);
00813 void  CmiError(const char *, ...);
00814 int   CmiScanf(const char *, ...);
00815 /* CmiFlush is disabled in this case */
00816 #define CmiFlush(stream) 
00817 
00818 #else /* standard definitions */
00819 
00820 #include <stdio.h>
00821 
00822 /*
00823  * I made vprintf functions for CmiPrintf and CmiError, but on the
00824  * O2K, there is no equivalent vscanf!
00825 
00826  #define CmiPrintf printf
00827  #define CmiError  printf
00828 */
00829 #include <stdarg.h>
00830 
00831 void  CmiPrintf(const char *format, ...);
00832 void  CmiError(const char *format, ...);
00833 /* CmiFlush works only when CMK_CMIPRINTF_IS_A_BUILTIN is false */
00834 #define CmiFlush(stream)  fflush(stream);
00835 #define CmiScanf  scanf
00836 
00837 #endif
00838 
00839 #if defined(__STDC__) || defined(__cplusplus)
00840 #define __CMK_STRING(x) #x
00841 #else
00842 #define __CMK_STRING(x) "x"
00843 #endif
00844 
00845 #if ! CMK_ERROR_CHECKING
00846 #define CmiAssert(expr) ((void) 0)
00847 #else
00848 extern void __cmi_assert(const char *, const char *, int);
00849 #define CmiAssert(expr) \
00850   ((void) ((expr) ? 0 :                   \
00851      (__cmi_assert (__CMK_STRING(expr), __FILE__, __LINE__), 0)))
00852 #endif
00853 
00854 typedef void (*CmiStartFn)(int argc, char **argv);
00855 
00856 /********* CSD - THE SCHEDULER ********
00857   @addtogroup ConverseScheduler
00858   @{
00859 */
00860 CpvExtern(int, _ccd_numchecks);
00861 extern void  CcdCallBacks();
00862 #define CsdPeriodic() do{ if (CpvAccess(_ccd_numchecks)-- <= 0) CcdCallBacks(); } while(0)
00863 #define CsdResetPeriodic()    CpvAccess(_ccd_numchecks) = 0;
00864 
00865 extern void  CsdEndIdle(void);
00866 extern void  CsdStillIdle(void);
00867 extern void  CsdBeginIdle(void);
00868 
00869 typedef struct {
00870   void *localQ;
00871   void *nodeQ;
00872   void *schedQ;
00873   int *localCounter;
00874 #if CMK_OBJECT_QUEUE_AVAILABLE
00875   void *objQ;
00876 #endif
00877   CmiNodeLock nodeLock;
00878 #if CMK_GRID_QUEUE_AVAILABLE
00879   void *gridQ;
00880 #endif
00881 } CsdSchedulerState_t;
00882 extern void CsdSchedulerState_new(CsdSchedulerState_t *state);
00883 extern void *CsdNextMessage(CsdSchedulerState_t *state);
00884 extern void *CsdNextLocalNodeMessage(CsdSchedulerState_t *state);
00885 
00886 extern void  *CmiGetNonLocal(void);
00887 extern void   CmiNotifyIdle(void);
00888 
00889 /*Different kinds of schedulers: generic, eternal, counting, polling*/
00890 extern  int CsdScheduler(int maxmsgs);
00891 extern void CsdScheduleForever(void);
00892 extern  int CsdScheduleCount(int maxmsgs);
00893 extern void CsdSchedulePoll(void);
00894 extern void CsdScheduleNodePoll(void);
00895 
00896 #define CsdExitScheduler()  (CpvAccess(CsdStopFlag)++)
00897 
00899 #if CMK_SPANTREE_USE_COMMON_CODE
00900 
00901 #define CST_W  (CMK_SPANTREE_MAXSPAN)
00902 #define CST_NN (CmiNumNodes())
00903 #define CmiNodeSpanTreeParent(n) ((n)?(((n)-1)/CST_W):(-1))
00904 #define CmiNodeSpanTreeChildren(n,c) do {\
00905           int _i; \
00906           for(_i=0; _i<CST_W; _i++) { \
00907             int _x = (n)*CST_W+_i+1; \
00908             if(_x<CST_NN) (c)[_i]=_x; \
00909           }\
00910         } while(0)
00911 #define CmiNumNodeSpanTreeChildren(n) ((((n)+1)*CST_W<CST_NN)? CST_W : \
00912           ((((n)*CST_W+1)>=CST_NN)?0:((CST_NN-1)-(n)*CST_W)))
00913 #define CST_R(p) (CmiRankOf(p))
00914 #define CST_NF(n) (CmiNodeFirst(n))
00915 #define CST_SP(n) (CmiNodeSpanTreeParent(n))
00916 #define CST_ND(p) (CmiNodeOf(p))
00917 #define CST_NS(p) (CmiNodeSize(CST_ND(p)))
00918 #define CmiSpanTreeParent(p) ((p)?(CST_R(p)?(CST_NF(CST_ND(p))+(CST_R(p)-1)/CST_W):CST_NF(CST_SP(CST_ND(p)))):(-1))
00919 #define CST_C(p) (((CST_R(p)+1)*CST_W<CST_NS(p))?CST_W:(((CST_R(p)*CST_W+1)>=CST_NS(p))?0:((CST_NS(p)-1)-CST_R(p)*CST_W)))
00920 #define CST_SC(p) (CmiNumNodeSpanTreeChildren(CST_ND(p)))
00921 #define CmiNumSpanTreeChildren(p) (CST_R(p)?CST_C(p):(CST_SC(p)+CST_C(p)))
00922 #define CmiSpanTreeChildren(p,c) do {\
00923           int _i,_c=0; \
00924           if(CST_R(p)==0) { \
00925             for(_i=0;_i<CST_W;_i++) { \
00926               int _x = CST_ND(p)*CST_W+_i+1; \
00927               if(_x<CST_NN) (c)[_c++]=CST_NF(_x); \
00928             }\
00929           } \
00930           for(_i=0;_i<CST_W;_i++) { \
00931             int _x = CST_R(p)*CST_W+_i+1; \
00932             if(_x<CST_NS(p)) (c)[_c++]=CST_NF(CST_ND(p))+_x; \
00933           }\
00934         } while(0)
00935 
00936 #else
00937 
00938 int      CmiNumSpanTreeChildren(int) ;
00939 int      CmiSpanTreeParent(int) ;
00940 void     CmiSpanTreeChildren(int node, int *children);
00941 int      CmiNumNodeSpanTreeChildren(int);
00942 int      CmiNodeSpanTreeParent(int) ;
00943 void     CmiNodeSpanTreeChildren(int node, int *children) ;
00944 #endif
00945 
00946 /****** MULTICAST GROUPS ******/
00947 
00948 typedef CMK_MULTICAST_GROUP_TYPE CmiGroup;
00949 
00950 void     CmiGroupInit();
00951 CmiGroup CmiEstablishGroup(int npes, int *pes);
00952 void     CmiLookupGroup(CmiGroup grp, int *npes, int **pes);
00953 
00954 /****** CMI MESSAGE TRANSMISSION ******/
00955 
00956 /* Utility function: it packs a multiple chunk message into a singly one.
00957  * Receives the two return values outsize and outdata to return the size of the
00958  * composed message and the message itself. It receives the number of chunks to
00959  * compact, their sizes and datas. The types of the parameters are:
00960  *
00961  * int outsize, inndata, insizes;
00962  * char *outdata;
00963  * char **indatas;
00964  *
00965  * If inndata is negative, it means that the messages need to be copied together
00966  * with their memory header at the beginning (message nesting), and padded to 8
00967  * bytes. The first message never has its memory header attached (it uses the
00968  * one of the new message).
00969  */
00970 
00971 #define VECTOR_COMPACT(outsize,outdata,inndata,insizes,indatas,chunkHeaderSize) {\
00972   int i;\
00973   char *tmp;\
00974   outsize=0;\
00975   if (inndata>=0) for(i=0; i<inndata; ++i) outsize += insizes[i];\
00976   else {\
00977     for(i=0; i<-inndata; ++i) outsize += ALIGN8(insizes[i]);\
00978     outsize -= (inndata+1) * chunkHeaderSize;\
00979   }\
00980   outdata = (char *)CmiAlloc(outsize);\
00981   if (!outdata) fprintf(stderr, "%d: Out of mem\n", CmiMyNode());\
00982   tmp = outdata;\
00983   if (inndata>=0) {\
00984     for (i=0; i<inndata; ++i) {\
00985       memcpy(tmp, indatas[i], insizes[i]);\
00986       tmp += insizes[i];\
00987     }\
00988   } else {\
00989     memcpy(tmp, indatas[0], insizes[0]);\
00990     tmp += ALIGN8(insizes[0]);\
00991     for (i=0; i<-inndata; ++i) {\
00992       memcpy(tmp, indatas[i]-chunkHeaderSize, insizes[i]+chunkHeaderSize);\
00993       tmp += ALIGN8(insizes[i])+chunkHeaderSize;\
00994     }\
00995   }\
00996 }
00997 
00998 void CmiPushPE(int, void*);
00999 
01000 void          CmiSyncSendFn(int, int, char *);
01001 CmiCommHandle CmiAsyncSendFn(int, int, char *);
01002 void          CmiFreeSendFn(int, int, char *);
01003 
01004 void          CmiSyncBroadcastFn(int, char *);
01005 CmiCommHandle CmiAsyncBroadcastFn(int, char *);
01006 void          CmiFreeBroadcastFn(int, char *);
01007 
01008 void          CmiSyncBroadcastAllFn(int, char *);
01009 CmiCommHandle CmiAsyncBroadcastAllFn(int, char *);
01010 void          CmiFreeBroadcastAllFn(int, char *);
01011 
01012 void          CmiSyncListSendFn(int, int *, int, char*);
01013 CmiCommHandle CmiAsyncListSendFn(int, int *, int, char*);
01014 void          CmiFreeListSendFn(int, int *, int, char*);
01015 
01016 void          CmiSyncMulticastFn(CmiGroup, int, char*);
01017 CmiCommHandle CmiAsyncMulticastFn(CmiGroup, int, char*);
01018 void          CmiFreeMulticastFn(CmiGroup, int, char*);
01019 
01020 typedef void * (*CmiReduceMergeFn)(int*,void*,void**,int);
01021 typedef void (*CmiReducePupFn)(void*,void*);
01022 typedef void (*CmiReduceDeleteFn)(void*);
01023 
01024 typedef struct {
01025   void *localData;
01026   char **remoteData;
01027   int localSize;
01028   short int numRemoteReceived;
01029   short int numChildren;
01030   int parent;
01031   CmiUInt2 seqID;
01032   char localContributed;
01033   struct {
01034     CmiHandler destination;
01035     CmiReduceMergeFn mergeFn;
01036     CmiReducePupFn pupFn;
01037     CmiReduceDeleteFn deleteFn;
01038   } ops;
01039 } CmiReduction;
01040 
01041 typedef CmiUInt2 CmiReductionID;
01042 
01043 void * CmiReduceMergeFn_random(int*, void*, void**, int);
01044 
01045 void CmiReduce(void *msg, int size, CmiReduceMergeFn mergeFn);
01046 void CmiReduceStruct(void *data, CmiReducePupFn pupFn,
01047                      CmiReduceMergeFn mergeFn, CmiHandler dest,
01048                      CmiReduceDeleteFn deleteFn);
01049 void CmiReduceID(void *msg, int size, CmiReduceMergeFn mergeFn, CmiReductionID id);
01050 void CmiReduceStructID(void *data, CmiReducePupFn pupFn,
01051                      CmiReduceMergeFn mergeFn, CmiHandler dest,
01052                      CmiReduceDeleteFn deleteFn, CmiReductionID id);
01053 void CmiListReduce(int npes, int *pes, void *msg, int size, CmiReduceMergeFn mergeFn, CmiReductionID id);
01054 void CmiListReduceStruct(int npes, int *pes,
01055                      void *data, CmiReducePupFn pupFn,
01056                      CmiReduceMergeFn mergeFn, CmiHandler dest,
01057                      CmiReduceDeleteFn deleteFn, CmiReductionID id);
01058 void CmiGroupReduce(CmiGroup grp, void *msg, int size, CmiReduceMergeFn mergeFn, CmiReductionID id);
01059 void CmiGroupReduceStruct(CmiGroup grp, void *data, CmiReducePupFn pupFn,
01060                      CmiReduceMergeFn mergeFn, CmiHandler dest,
01061                      CmiReduceDeleteFn deleteFn, CmiReductionID id);
01062 void CmiNodeReduce(void *msg, int size, CmiReduceMergeFn mergeFn, int, int, int);
01063 void CmiNodeReduceStruct(void *data, CmiReducePupFn pupFn,
01064                          CmiReduceMergeFn mergeFn, CmiHandler dest,
01065                          CmiReduceDeleteFn deleteFn);
01066 int CmiGetReductionHandler();
01067 CmiHandler CmiGetReductionDestination();
01068 CmiReductionID CmiGetGlobalReduction();
01069 CmiReductionID CmiGetDynamicReduction();
01070 void CmiGetDynamicReductionRemote(int handlerIdx, int pe, int dataSize, void *data);
01071 
01072 /* If the second parameter (the number of chunks to send) is negative, then
01073  * every message will be started aligned with 8 bytes, and a message header will
01074  * be preponed to every message (message nesting), except the first one which
01075  * uses that of the entire message.
01076  */
01077 void          CmiSyncVectorSend(int, int, int *, char **);
01078 CmiCommHandle CmiAsyncVectorSend(int, int, int *, char **);
01079 void          CmiSyncVectorSendAndFree(int, int, int *, char **);
01080 
01081 void          CmiMultipleSend(unsigned int, int, int *, char **);
01082 void          CmiMultipleIsend(unsigned int, int, int *, char **);
01083 
01084 int           CmiAsyncMsgSent(CmiCommHandle);
01085 void          CmiReleaseCommHandle(CmiCommHandle);
01086 
01087 #define CmiSyncSend(p,s,m)              (CmiSyncSendFn((p),(s),(char *)(m)))
01088 #define CmiAsyncSend(p,s,m)             (CmiAsyncSendFn((p),(s),(char *)(m)))
01089 #define CmiSyncSendAndFree(p,s,m)       (CmiFreeSendFn((p),(s),(char *)(m)))
01090 
01091 #define CmiSyncBroadcast(s,m)           (CmiSyncBroadcastFn((s),(char *)(m)))
01092 #define CmiAsyncBroadcast(s,m)          (CmiAsyncBroadcastFn((s),(char *)(m)))
01093 #define CmiSyncBroadcastAndFree(s,m)    (CmiFreeBroadcastFn((s),(char *)(m)))
01094 
01095 #define CmiSyncBroadcastAll(s,m)        (CmiSyncBroadcastAllFn((s),(char *)(m)))
01096 #define CmiAsyncBroadcastAll(s,m)       (CmiAsyncBroadcastAllFn((s),(char *)(m)))
01097 #define CmiSyncBroadcastAllAndFree(s,m) (CmiFreeBroadcastAllFn((s),(char *)(m)))
01098 
01099 #define CmiSyncListSend(n,l,s,m)        (CmiSyncListSendFn((n),(l),(s),(char *)(m)))
01100 #define CmiAsyncListSend(n,l,s,m)       (CmiAsyncListSendFn((n),(l),(s),(char *)(m)))
01101 #define CmiSyncListSendAndFree(n,l,s,m) (CmiFreeListSendFn((n),(l),(s),(char *)(m)))
01102 
01103 #define CmiSyncMulticast(g,s,m)         (CmiSyncMulticastFn((g),(s),(char*)(m)))
01104 #define CmiAsyncMulticast(g,s,m)        (CmiAsyncMulticastFn((g),(s),(char*)(m)))
01105 #define CmiSyncMulticastAndFree(g,s,m)  (CmiFreeMulticastFn((g),(s),(char*)(m)))
01106 
01107 #if CMK_NODE_QUEUE_AVAILABLE
01108 void          CmiSyncNodeSendFn(int, int, char *);
01109 CmiCommHandle CmiAsyncNodeSendFn(int, int, char *);
01110 void          CmiFreeNodeSendFn(int, int, char *);
01111 
01112 void          CmiSyncNodeBroadcastFn(int, char *);
01113 CmiCommHandle CmiAsyncNodeBroadcastFn(int, char *);
01114 void          CmiFreeNodeBroadcastFn(int, char *);
01115 
01116 void          CmiSyncNodeBroadcastAllFn(int, char *);
01117 CmiCommHandle CmiAsyncNodeBroadcastAllFn(int, char *);
01118 void          CmiFreeNodeBroadcastAllFn(int, char *);
01119 #endif
01120 
01121 #if CMK_NODE_QUEUE_AVAILABLE
01122 #define CmiSyncNodeSend(p,s,m)          (CmiSyncNodeSendFn((p),(s),(char *)(m)))
01123 #define CmiAsyncNodeSend(p,s,m)             (CmiAsyncNodeSendFn((p),(s),(char *)(m)))
01124 #define CmiSyncNodeSendAndFree(p,s,m)       (CmiFreeNodeSendFn((p),(s),(char *)(m)))
01125 #define CmiSyncNodeBroadcast(s,m)           (CmiSyncNodeBroadcastFn((s),(char *)(m)))
01126 #define CmiAsyncNodeBroadcast(s,m)          (CmiAsyncNodeBroadcastFn((s),(char *)(m)))
01127 #define CmiSyncNodeBroadcastAndFree(s,m)    (CmiFreeNodeBroadcastFn((s),(char *)(m)))
01128 #define CmiSyncNodeBroadcastAll(s,m)        (CmiSyncNodeBroadcastAllFn((s),(char *)(m)))
01129 #define CmiAsyncNodeBroadcastAll(s,m)       (CmiAsyncNodeBroadcastAllFn((s),(char *)(m)))
01130 #define CmiSyncNodeBroadcastAllAndFree(s,m) (CmiFreeNodeBroadcastAllFn((s),(char *)(m)))
01131 #else
01132 
01133 #define CmiSyncNodeSend(n,s,m)        CmiSyncSend(CmiNodeFirst(n),s,m)
01134 #define CmiAsyncNodeSend(n,s,m)       CmiAsyncSend(CmiNodeFirst(n),s,m)
01135 #define CmiSyncNodeSendAndFree(n,s,m) CmiSyncSendAndFree(CmiNodeFirst(n),s,m)
01136 #if CMK_UTH_VERSION || CMK_MULTICORE
01137 #define CmiSyncNodeBroadcast(s,m)           do { \
01138           int _i; \
01139           for(_i=0; _i<CmiNumNodes(); _i++) \
01140             if(_i != CmiMyNode()) \
01141               CmiSyncSend(CmiNodeFirst(_i),s,m); \
01142         } while(0)
01143 #define CmiAsyncNodeBroadcast(s,m)          CmiSyncNodeBroadcast(s,m)
01144 #define CmiSyncNodeBroadcastAndFree(s,m)    do { \
01145           CmiSyncNodeBroadcast(s,m); \
01146           CmiFree(m); \
01147         } while(0)
01148 #define CmiSyncNodeBroadcastAll(s,m)           do { \
01149           int _i; \
01150           for(_i=0; _i<CmiNumNodes(); _i++) \
01151             CmiSyncSend(CmiNodeFirst(_i),s,m); \
01152         } while(0)
01153 #define CmiAsyncNodeBroadcastAll(s,m)       CmiSyncNodeBroadcastAll(s,m)
01154 #define CmiSyncNodeBroadcastAllAndFree(s,m) do { \
01155           CmiSyncNodeBroadcastAll(s,m); \
01156           CmiFree(m); \
01157         } while(0)
01158 #else
01159 #define CmiSyncNodeBroadcast(s,m)           CmiSyncBroadcast(s,m)
01160 #define CmiAsyncNodeBroadcast(s,m)          CmiAsyncBroadcast(s,m)
01161 #define CmiSyncNodeBroadcastAndFree(s,m)    CmiSyncBroadcastAndFree(s,m)
01162 #define CmiSyncNodeBroadcastAll(s,m)        CmiSyncBroadcastAll(s,m)
01163 #define CmiAsyncNodeBroadcastAll(s,m)       CmiAsyncBroadcastAll(s,m)
01164 #define CmiSyncNodeBroadcastAllAndFree(s,m) CmiSyncBroadcastAllAndFree(s,m)
01165 #endif
01166 #endif
01167 
01168 /******** CMI MESSAGE RECEPTION ********/
01169 
01170 void   CmiDeliversInit();
01171 int    CmiDeliverMsgs(int maxmsgs);
01172 void   CmiDeliverSpecificMsg(int handler);
01173 void   CmiHandleMessage(void *msg);
01174 
01175 /******** CQS: THE QUEUEING SYSTEM ********
01176  * @addtogroup CharmScheduler
01177  * @{ 
01178  */
01179 #define CQS_QUEUEING_FIFO 2
01180 #define CQS_QUEUEING_LIFO 3
01181 #define CQS_QUEUEING_IFIFO 4
01182 #define CQS_QUEUEING_ILIFO 5
01183 #define CQS_QUEUEING_BFIFO 6
01184 #define CQS_QUEUEING_BLIFO 7
01185 #define CQS_QUEUEING_LFIFO 8
01186 #define CQS_QUEUEING_LLIFO 9
01187 
01190 /****** CTH: THE LOW-LEVEL THREADS PACKAGE ******/
01191 
01192 typedef struct CthThreadStruct *CthThread;
01193 typedef struct {
01194   /*Start with a message header so threads can be enqueued 
01195     as messages (e.g., by CthEnqueueNormalThread in convcore.c)
01196   */
01197   char cmicore[CmiReservedHeaderSize];
01198   CthThread thread;
01199   int serialNo;
01200 } CthThreadToken;
01201 
01202 CthThreadToken *CthGetToken(CthThread);
01203 
01204 typedef void        (*CthVoidFn)();
01205 typedef void        (*CthAwkFn)(CthThreadToken *,int,
01206                                 int prioBits,unsigned int *prioptr);
01207 typedef CthThread   (*CthThFn)();
01208 
01209 void       CthSetSerialNo(CthThread t, int no);
01210 int        CthImplemented(void);
01211 
01212 int        CthMigratable();
01213 CthThread  CthPup(pup_er, CthThread);
01214 
01215 CthThread  CthSelf(void);
01216 CthThread  CthCreate(CthVoidFn, void *, int);
01217 CthThread  CthCreateMigratable(CthVoidFn, void *, int);
01218 void       CthResume(CthThread);
01219 void       CthFree(CthThread);
01220 
01221 void       CthSetSuspendable(CthThread, int);
01222 int        CthIsSuspendable(CthThread);
01223 
01224 /* added for bigsim out-of-core emulation */
01225 void       CthPrintThdMagic(CthThread); 
01226 void       CthPrintThdStack(CthThread);
01227 
01228 void       CthSuspend(void);
01229 void       CthAwaken(CthThread);
01230 void       CthAwakenPrio(CthThread, int, int, unsigned int *);
01231 void       CthSetStrategy(CthThread, CthAwkFn, CthThFn);
01232 void       CthSetStrategyDefault(CthThread);
01233 void       CthYield(void);
01234 void       CthYieldPrio(int,int,unsigned int*);
01235 
01236 void       CthSetNext(CthThread t, CthThread next);
01237 CthThread  CthGetNext(CthThread t);
01238 
01239 void       CthSwitchThread(CthThread t);
01240 
01241 size_t     CthStackOffset(CthThread t, char *p);
01242 char     * CthPointer(CthThread t, size_t pos);
01243 
01244 /* unimplemented: preemptive threads */
01245 void       CthAutoYield(CthThread t, int flag);
01246 double     CthAutoYieldFreq(CthThread t);
01247 void       CthAutoYieldBlock(void);
01248 void       CthAutoYieldUnblock(void);
01249 
01250 /* Converse Thread Global (Ctg) global variable manipulation */
01251 typedef struct CtgGlobalStruct *CtgGlobals;
01252 
01254 void CtgInit(void);
01256 CpvExtern(int, CmiPICMethod);
01257 
01259 CtgGlobals CtgCreate(CthThread tid);
01261 void CtgInstall(CtgGlobals g);
01263 CtgGlobals CtgPup(pup_er, CtgGlobals g);
01265 void CtgFree(CtgGlobals g);
01267 CtgGlobals CtgCurrentGlobals(void);
01268 void CtgInstall_var(CtgGlobals g, void *ptr);
01269 void CtgUninstall_var(CtgGlobals g, void *ptr);
01270 
01271 /* The thread listener structure. The user must register one such listener
01272         if he wants to find out when a thread is suspended or when it starts running
01273         or gets destroyed. It can be used for tracing etc.
01274 */
01275 
01276 struct CthThreadListener;
01277 
01278 typedef void (*CthThreadListener_suspend)(struct CthThreadListener *l);
01279 typedef void (*CthThreadListener_resume)(struct CthThreadListener *l);
01280 typedef void (*CthThreadListener_free)(struct CthThreadListener *l);
01281 
01282 struct CthThreadListener {
01284        CthThreadListener_suspend suspend;
01285 
01287        CthThreadListener_resume resume;
01288 
01290        CthThreadListener_free free;
01291 
01295        void *data;
01296 
01300        CthThread thread;
01301 
01305        struct CthThreadListener *next;
01306 };
01307 
01315 void CthAddListener(CthThread th,struct CthThreadListener *l);
01316 
01322 void CthUserAddListeners(CthThread th);
01323 
01324 /****** Isomalloc: Migratable Memory Allocation ********/
01325 /*Simple block-by-block interface:*/
01326 void *CmiIsomalloc(int sizeInBytes, CthThread tid);
01327 void *CmiIsomallocAlign(size_t align, size_t size, CthThread t);
01328 void  CmiIsomallocPup(pup_er p,void **block);
01329 void  CmiIsomallocFree(void *block);
01330 int   CmiIsomallocEnabled();
01331 void  CmiEnableIsomalloc();
01332 void  CmiDisableIsomalloc();
01333 
01334 CmiInt8   CmiIsomallocLength(void *block);
01335 int   CmiIsomallocInRange(void *addr);
01336 
01337 /*List-of-blocks interface:*/
01338 struct CmiIsomallocBlockList {/*Circular doubly-linked list of blocks:*/
01339         struct CmiIsomallocBlockList *prev,*next;
01340         /*actual data of block follows here...*/
01341 };
01342 typedef struct CmiIsomallocBlockList CmiIsomallocBlockList;
01343 
01344 /*Build/pup/destroy an entire blockList.*/
01345 CmiIsomallocBlockList *CmiIsomallocBlockListNew(CthThread t);
01346 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **l, CthThread tid);
01347 void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l);
01348 
01349 /*Allocate/free a block from this blockList*/
01350 void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,size_t nBytes);
01351 void *CmiIsomallocBlockListMallocAlign(CmiIsomallocBlockList *l,size_t align,size_t nBytes);
01352 void CmiIsomallocBlockListFree(void *doomedMallocedBlock);
01353 
01354 
01355 /****** CTH: THREAD-PRIVATE VARIABLES ******/
01356 
01357 #if CMK_THREADS_REQUIRE_NO_CPV
01358 
01359 #define CthCpvDeclare(t,v)    t v
01360 #define CthCpvExtern(t,v)     extern t v
01361 #define CthCpvStatic(t,v)     static t v
01362 #define CthCpvInitialize(t,v) do {} while(0)
01363 #define CthCpvAccess(x)       x
01364 
01365 #else
01366 
01367 #define CthCpvDeclare(t,v)    CpvDeclare(t,v)
01368 #define CthCpvExtern(t,v)     CpvExtern(t,v)
01369 #define CthCpvStatic(t,v)     CpvStaticDeclare(t,v)
01370 #define CthCpvInitialize(t,v) CpvInitialize(t,v)
01371 #define CthCpvAccess(x)       CpvAccess(x)
01372 
01373 #endif
01374 
01375 CthCpvExtern(char *,CthData);
01376 extern int CthRegister(int dataSize);
01377 extern void CthRegistered(int dataOffMax);
01378 extern char *CthGetData(CthThread t);
01379 
01380 #define CtvDeclare(t,v)         typedef t CtvType##v; CsvDeclare(int,CtvOffs##v)=(-1)
01381 #define CtvStaticDeclare(t,v)   typedef t CtvType##v; CsvStaticDeclare(int,CtvOffs##v)=(-1)
01382 #define CtvExtern(t,v)          typedef t CtvType##v; CsvExtern(int,CtvOffs##v)
01383 #define CtvAccess(v)            (*((CtvType##v *)(CthCpvAccess(CthData)+CsvAccess(CtvOffs##v))))
01384 #define CtvAccessOther(t,v)            (*((CtvType##v *)(CthGetData(t)+CsvAccess(CtvOffs##v))))
01385 #define CtvInitialize(t,v)      do { \
01386         if(CsvAccess(CtvOffs##v)==(-1)) \
01387                 CsvAccess(CtvOffs##v)=CthRegister(sizeof(CtvType##v));\
01388         else CthRegistered(CsvAccess(CtvOffs##v)+sizeof(CtvType##v));\
01389 } while(0)
01390 
01391 /****** CFUTURE: CONVERSE FUTURES ******/
01392 
01393 typedef struct Cfuture_s
01394 {
01395   int pe;
01396   struct Cfuture_data_s *data;
01397 }
01398 Cfuture;
01399 
01400 #define CfutureValueData(v) ((void*)((v)->rest))
01401 
01402 Cfuture       CfutureCreate(void);
01403 void          CfutureSet(Cfuture f, void *val, int len);
01404 void         *CfutureWait(Cfuture f);
01405 void          CfutureDestroy(Cfuture f);
01406 
01407 void         *CfutureCreateBuffer(int bytes);
01408 void          CfutureDestroyBuffer(void *val);
01409 void          CfutureStoreBuffer(Cfuture f, void *value);
01410 
01411 #define       CfuturePE(f) ((f).pe)
01412 
01413 void CfutureInit();
01414 
01415 /****** CLD: THE LOAD BALANCER ******/
01416 
01417 #define CLD_ANYWHERE (-1)
01418 #define CLD_BROADCAST (-2)
01419 #define CLD_BROADCAST_ALL (-3)
01420 
01421 typedef void (*CldPackFn)(void *msg);
01422 
01423 typedef void (*CldInfoFn)(void *msg, 
01424                           CldPackFn *packer,
01425                           int *len,
01426                           int *queueing,
01427                           int *priobits, 
01428                           unsigned int **prioptr);
01429 
01430 typedef int (*CldEstimator)(void);
01431 
01432 int CldRegisterInfoFn(CldInfoFn fn);
01433 int CldRegisterPackFn(CldPackFn fn);
01434 void CldRegisterEstimator(CldEstimator fn);
01435 int CldEstimate(void);
01436 char *CldGetStrategy(void);
01437 
01438 void CldEnqueue(int pe, void *msg, int infofn);
01439 void CldEnqueueMulti(int npes, int *pes, void *msg, int infofn);
01440 void CldEnqueueGroup(CmiGroup grp, void *msg, int infofn);
01441 void CldNodeEnqueue(int node, void *msg, int infofn);
01442 
01443 /****** CMM: THE MESSAGE MANAGER ******/
01444 
01445 typedef struct CmmTableStruct *CmmTable;
01446 
01447 #define CmmWildCard (-1)
01448 
01449 typedef void (*CmmPupMessageFn)(pup_er p,void **msg);
01450 CmmTable CmmPup(pup_er p, CmmTable t, CmmPupMessageFn msgpup);
01451 
01452 CmmTable   CmmNew();
01453 void       CmmFree(CmmTable t);
01454 void       CmmFreeAll(CmmTable t);
01455 void       CmmPut(CmmTable t, int ntags, int *tags, void *msg);
01456 void      *CmmFind(CmmTable t, int ntags, int *tags, int *returntags, int del);
01457 int        CmmEntries(CmmTable t);
01458 int        CmmGetLastTag(CmmTable t, int ntags, int *tags);
01459 #define    CmmGet(t,nt,tg,rt)   (CmmFind((t),(nt),(tg),(rt),1))
01460 #define    CmmProbe(t,nt,tg,rt) (CmmFind((t),(nt),(tg),(rt),0))
01461 
01462 /******** ConverseInit and ConverseExit ********/
01463 
01464 void ConverseInit(int, char**, CmiStartFn, int, int);
01465 void ConverseExit(void);
01466 
01467 void CmiAbort(const char *);
01468 void CmiOutOfMemory(int nBytes);
01469 
01470 #if CMK_MEMCHECK_OFF
01471 #define _MEMCHECK(p) do{}while(0)
01472 #else
01473 #define _MEMCHECK(p) do { \
01474                          if ((p)==0) CmiOutOfMemory(-1);\
01475                      } while(0)
01476 #endif
01477 
01478 /******** CONVCONDS ********/
01479 
01480 typedef void (*CcdVoidFn)(void *userParam,double curWallTime);
01481 
01482 /*CPU conditions*/
01483 #define CcdPROCESSOR_BEGIN_BUSY 0
01484 #define CcdPROCESSOR_END_IDLE 0 /*Synonym*/
01485 #define CcdPROCESSOR_BEGIN_IDLE 1
01486 #define CcdPROCESSOR_END_BUSY 1 /*Synonym*/
01487 #define CcdPROCESSOR_STILL_IDLE 2
01488 
01489 /*Periodic calls*/
01490 #define CcdPERIODIC       16 /*every few ms*/
01491 #define CcdPERIODIC_10ms  17 /*every 10ms (100Hz)*/
01492 #define CcdPERIODIC_100ms 18 /*every 100ms (10Hz)*/
01493 #define CcdPERIODIC_1second  19 /*every second*/
01494 #define CcdPERIODIC_1s       19 /*every second*/
01495 #define CcdPERIODIC_5s       20 /*every second*/
01496 #define CcdPERIODIC_5seconds 20 /*every second*/
01497 #define CcdPERIODIC_10second 21 /*every 10 seconds*/
01498 #define CcdPERIODIC_10seconds 21 /*every 10 seconds*/
01499 #define CcdPERIODIC_10s      21 /*every 10 seconds*/
01500 #define CcdPERIODIC_1minute  22 /*every minute*/
01501 #define CcdPERIODIC_2minute  23 /*every 2 minute*/
01502 #define CcdPERIODIC_5minute  24 /*every 5 minute*/
01503 #define CcdPERIODIC_10minute 25 /*every 10 minutes*/
01504 #define CcdPERIODIC_1hour    26 /*every hour*/
01505 #define CcdPERIODIC_12hour   27 /*every 12 hours*/
01506 #define CcdPERIODIC_1day     28 /*every day*/
01507 
01508 /*Other conditions*/
01509 #define CcdQUIESCENCE 30
01510 #define CcdTOPOLOGY_AVAIL  31
01511 #define CcdSIGUSR1 32+1
01512 #define CcdSIGUSR2 32+2
01513 
01514 /*User-defined conditions start here*/
01515 #define CcdUSER    48
01516 
01517 #define CcdIGNOREPE   -2
01518 #if CMK_CONDS_USE_SPECIAL_CODE
01519 typedef int (*CmiSwitchToPEFnPtr)(int pe);
01520 extern CmiSwitchToPEFnPtr CmiSwitchToPE;
01521 #else
01522 #define CmiSwitchToPE(pe)  pe
01523 #endif
01524 void CcdCallFnAfter(CcdVoidFn fnp, void *arg, double msecs);
01525 int CcdCallOnCondition(int condnum, CcdVoidFn fnp, void *arg);
01526 int CcdCallOnConditionKeep(int condnum, CcdVoidFn fnp, void *arg);
01527 void CcdCallFnAfterOnPE(CcdVoidFn fnp, void *arg, double msecs, int pe);
01528 int CcdCallOnConditionOnPE(int condnum, CcdVoidFn fnp, void *arg, int pe);
01529 int CcdCallOnConditionKeepOnPE(int condnum, CcdVoidFn fnp, void *arg, int pe);
01530 void CcdCancelCallOnCondition(int condnum, int idx);
01531 void CcdCancelCallOnConditionKeep(int condnum, int idx);
01532 void CcdRaiseCondition(int condnum);
01533 
01534 /* Command-Line-Argument handling */
01535 void CmiArgGroup(const char *parentName,const char *groupName);
01536 int CmiGetArgInt(char **argv,const char *arg,int *optDest);
01537 int CmiGetArgIntDesc(char **argv,const char *arg,int *optDest,const char *desc);
01538 int CmiGetArgLong(char **argv,const char *arg,CmiInt8 *optDest);
01539 int CmiGetArgLongDesc(char **argv,const char *arg,CmiInt8 *optDest,const char *desc);
01540 int CmiGetArgDouble(char **argv,const char *arg,double *optDest);
01541 int CmiGetArgDoubleDesc(char **argv,const char *arg,double *optDest,const char *desc);
01542 int CmiGetArgString(char **argv,const char *arg,char **optDest);
01543 int CmiGetArgStringDesc(char **argv,const char *arg,char **optDest,const char *desc);
01544 int CmiGetArgFlag(char **argv,const char *arg);
01545 int CmiGetArgFlagDesc(char **argv,const char *arg,const char *desc);
01546 void CmiDeleteArgs(char **argv,int k);
01547 int CmiGetArgc(char **argv);
01548 char **CmiCopyArgs(char **argv);
01549 int CmiArgGivingUsage(void);
01550 
01559 void CmiBacktraceRecord(void **retPtrs,int nSkip,int *nLevels);
01560 
01565 char **CmiBacktraceLookup(void **srcPtrs,int nLevels);
01566 
01568 void CmiBacktracePrint(void **retPtrs,int nLevels);
01569 
01570 /* Print (to stdout) the names of the functions that have been 
01571    called up to this point. nSkip is the number of routines on the
01572    top of the stack to *not* print out. */
01573 void CmiPrintStackTrace(int nSkip);
01574 int CmiIsFortranLibraryCall();
01575 
01576 #if CMK_CMIDELIVERS_USE_COMMON_CODE
01577 CpvExtern(void*, CmiLocalQueue);
01578 #endif
01579 
01580 char *CmiCopyMsg(char *msg, int len);
01581 
01582 /******** Hypercube broadcast propagation (Binomial tree) ********/
01583 
01584 /*
01585   This routing will receive a number k containing the dimension in the hypercube
01586   to be used for the broadcast, i.e. k=0 means sending only to MyPe^1, k=1 means
01587   sending to MyPe^2 and MyPe^1, etc.
01588   The array dest_pes will be filled with the id of the processors to which send,
01589   it has to be already allocated, the size should be at least k+1 to allow
01590   enough space.
01591   It return the number of processors to which send, i.e. the size of dest_pes.
01592   This may be less than k+1 due to not complete hypercubes.
01593   For example with pow(2,n)+2 procs and 0 broadcasting, proc pow(2,n) will
01594   receive from 0 in the first step but then it has only proc pow(2,n)+1 as
01595   destination, so most of the other dimentions will be skipped.
01596 */
01597 int HypercubeGetBcastDestinations(int mype, int total_pes, int k, int *dest_pes);
01598 
01599 /******** Immediate Messages ********/
01600 
01601 CpvExtern(int, CmiImmediateMsgHandlerIdx);
01602 
01603 
01604 CpvExtern(unsigned, networkProgressCount);
01605 extern int networkProgressPeriod;
01606 
01607 #if !CMK_MACHINE_PROGRESS_DEFINED
01608 
01609 #define CmiNetworkProgress() 
01610 #define CmiNetworkProgressAfter(p) 
01611 #define CmiMachineProgressImpl()
01612 
01613 #else
01614 
01615 /*#ifdef __cplusplus
01616 extern "C" 
01617 #endif*/
01618 void CmiMachineProgressImpl();
01619 
01620 #define CmiNetworkProgress() {CpvAccess(networkProgressCount) ++; \
01621       if(CpvAccess(networkProgressCount) >=  networkProgressPeriod) { \
01622           CmiMachineProgressImpl(); \
01623           CpvAccess(networkProgressCount) = 0; \
01624       } \
01625 } \
01626 
01627 #define CmiNetworkProgressAfter(p) {CpvAccess(networkProgressCount) ++; \
01628       if(CpvAccess(networkProgressCount) >=  p) { \
01629           CmiMachineProgressImpl(); \
01630           CpvAccess(networkProgressCount) = 0; \
01631       } \
01632 } \
01633 
01634 #endif
01635 
01636 #define CmiProbeImmediateMsg CmiMachineProgressImpl
01637 
01638 /*
01639    to immediate-fy a Converse message, set the most significant bit to 1
01640    in the Converse handler (x|0x8000). 
01641 */
01642 #if CMK_IMMEDIATE_MSG
01643 void CmiDelayImmediate();
01644 #  define CmiBecomeImmediate(msg) do { \
01645         CmiSetHandler(msg, (CmiGetHandler(msg))|0x8000); \
01646      } while (0)
01647 #  define CmiIsImmediate(msg)      ((CmiGetHandler(msg)) & 0x8000) 
01648 #  define CmiImmediateHandler(msg) ((CmiGetHandler(msg)) ^ 0x8000)
01649 /*
01650 #  define CmiIsImmediate(msg)   ((CmiGetHandler(msg) == CpvAccessOther(CmiImmediateMsgHandlerIdx,0)))
01651 #  define CmiBecomeImmediate(msg) do {\
01652         CmiSetXHandler(msg,CmiGetHandler(msg)); \
01653         CmiSetHandler(msg,CpvAccessOther(CmiImmediateMsgHandlerIdx,0)); \
01654      } while (0)
01655 #  define CmiImemdiateHandler(msg) (CmiGetXHandler(msg))
01656 */
01657 /* 
01658   for non smp and non intr based version, it returns _immRunning
01659   for smp, this doesnot matter - CkMyPe() comparasion normaly fails and
01660            non threadsafe CqsEnqueueGeneral is avoided.
01661 */
01662 #if CMK_NET_VERSION && ! CMK_SMP && ! defined(CMK_CPV_IS_SMP)
01663 extern int _immRunning;
01664 #  define CmiImmIsRunning()        (_immRunning)
01665 #else
01666 #  define CmiImmIsRunning()        (0)
01667 #endif
01668 
01669 #else
01670 #  define CmiBecomeImmediate(msg) /* empty */
01671 #  define CmiIsImmediate(msg)   (0)
01672 #  define CmiImmIsRunning()       (0)
01673 #endif
01674 
01675 /******** Memory Fence ********/
01676 
01677 #if  CMK_SMP
01678 #if CMK_GCC_X86_ASM
01679 #define CmiMemoryReadFence()               __asm__ __volatile__("lfence" ::: "memory")
01680 #define CmiMemoryWriteFence()              __asm__ __volatile__("sfence" ::: "memory")
01681 #if 1
01682 #define CmiMemoryAtomicIncrement(someInt)  __asm__ __volatile__("lock incl (%0)" :: "r" (&(someInt)))
01683 #define CmiMemoryAtomicDecrement(someInt)  __asm__ __volatile__("lock decl (%0)" :: "r" (&(someInt)))
01684 #else
01685 /* this might be slightly faster, but does not compile with -O3 on net-darwin-x86_64 */
01686 #define CmiMemoryAtomicIncrement(someInt)  __asm__ __volatile__("lock incl %0" :: "m" (someInt))
01687 #define CmiMemoryAtomicDecrement(someInt)  __asm__ __volatile__("lock decl %0" :: "m" (someInt))
01688 #endif
01689 #define CmiMemoryAtomicFetchAndInc(input,output) __asm__ __volatile__( \
01690         "movl $1, %1\n\t" \
01691         "lock xaddl %1, %0" \
01692         : "=m"(input), "=r"(output) : "m"(input) : "memory")
01693 #elif CMK_GCC_IA64_ASM
01694 #define CmiMemoryReadFence()               __asm__ __volatile__("mf" ::: "memory")
01695 #define CmiMemoryWriteFence()              __asm__ __volatile__("mf" ::: "memory")
01696 #define CmiMemoryAtomicIncrement(someInt)  { int someInt_private; \
01697   __asm__ __volatile__("fetchadd4.rel %0=[%1],1": "=r" (someInt_private): "r"(&someInt) :"memory"); }
01698 #define CmiMemoryAtomicDecrement(someInt)  { uint64_t someInt_private; \
01699   __asm__ __volatile__("fetchadd4.rel %0=[%1],-1": "=r" (someInt_private): "r"(&someInt) :"memory"); }
01700 #define CmiMemoryAtomicFetchAndInc(input,output) __asm__ __volatile__("fetchadd4.rel %0=[%1],1": "=r" (output): "r"(&input) :"memory")
01701 #elif CMK_PPC_ASM
01702 #define CmiMemoryReadFence()               __asm__ __volatile__("eieio":::"memory")
01703 #define CmiMemoryWriteFence()              __asm__ __volatile__("eieio":::"memory")
01704 #define CmiMemoryAtomicIncrement(someInt)   { int someInt_private; \
01705      __asm__ __volatile__ (      \
01706         "loop%=:\n\t"       /* repeat until this succeeds */    \
01707         "lwarx  %1,0,%2\n\t" /* reserve the operand */   \
01708         "addi   %1,%1,1\n\t" /* add incr to it */        \
01709         "stwcx. %1,0,%2\n\t" /* put the sum back, and release it */      \
01710         "bne- loop%="       /* start-over on failure */ \
01711         : "=m"(someInt), "=&r"(someInt_private)      \
01712         : "r" (&someInt), "m"(someInt)       \
01713         : "memory"  \
01714      ); }
01715 #define CmiMemoryAtomicDecrement(someInt)   { int someInt_private; \
01716      __asm__ __volatile__ (      \
01717         "loop%=:\n\t"       /* repeat until this succeeds */    \
01718         "lwarx  %1,0,%2\n\t" /* reserve the operand */   \
01719         "subi   %1,%1,1\n\t" /* add incr to it */        \
01720         "stwcx. %1,0,%2\n\t" /* put the sum back, and release it */      \
01721         "bne- loop%="       /* start-over on failure */ \
01722         : "=m"(someInt), "=&r"(someInt_private)      \
01723         : "r" (&someInt), "m"(someInt)       \
01724         : "memory"  \
01725      ); }
01726 #define CmiMemoryAtomicFetchAndInc(input,output) __asm__ __volatile__ ( \
01727         "loop%=:  lwarx %1, 0, %2\n\t" \
01728         "addi %1, %1, 1\n\t" \
01729         "stwcx. %1, 0, %2\n\t" \
01730         "bne- loop%=" \
01731         : "=m"(input), "=&r"(output) : "r"(&input), "m"(input) : "memory")
01732 #else
01733 #define CMK_NO_ASM_AVAILABLE    1
01734 extern CmiNodeLock cmiMemoryLock;
01735 #define CmiMemoryReadFence()               { CmiLock(cmiMemoryLock); CmiUnlock(cmiMemoryLock); }
01736 #define CmiMemoryWriteFence()              { CmiLock(cmiMemoryLock); CmiUnlock(cmiMemoryLock); }
01737 #define CmiMemoryAtomicIncrement(someInt)  { CmiLock(cmiMemoryLock); someInt=someInt+1; CmiUnlock(cmiMemoryLock); }
01738 #define CmiMemoryAtomicDecrement(someInt)  { CmiLock(cmiMemoryLock); someInt=someInt-1; CmiUnlock(cmiMemoryLock); }
01739 #define CmiMemoryAtomicFetchAndInc(input,output) { CmiLock(cmiMemoryLock); output=input; input=output+1; CmiUnlock(cmiMemoryLock); }
01740 #endif
01741 #else
01742 #define CmiMemoryReadFence()
01743 #define CmiMemoryWriteFence()
01744 #define CmiMemoryAtomicIncrement(someInt)  someInt=someInt+1
01745 #define CmiMemoryAtomicDecrement(someInt)  someInt=someInt-1
01746 #define CmiMemoryAtomicFetchAndInc(input,output) output=input; input=output+1;
01747 #endif
01748 
01749 /******** Performance Counters ********/
01750 void CmiInitCounters();
01751 void CmiStartCounters(int events[], int numEvents);
01752 void CmiStopCounters(int events[], CMK_TYPEDEF_INT8 values[], int numEvents);
01753 
01754 /******** Trace ********/
01755 
01756 /* this is the type for thread ID, mainly used for projection. */
01757 #define OBJ_ID_SZ 4
01758 typedef struct _CmiObjId {
01759 int id[OBJ_ID_SZ];
01760   /* 
01761    * **CWL** Note: setting initial values to -1 does not seem to be done for 
01762    *               LDObjid. Potential consistency problems could arise. This
01763    *               will probably have to be dealt with later.
01764    */
01765 #ifdef __cplusplus
01766   _CmiObjId() { 
01767     for (int i=0; i<OBJ_ID_SZ; i++) {
01768       id[i] = -1;
01769     }
01770   }
01771   int isNull() {
01772     for (int i=0; i<OBJ_ID_SZ; i++) {
01773       if (id[i] != -1) return CmiFalse;
01774     }
01775     return CmiTrue;
01776   }
01777   CmiBool operator==(const struct _CmiObjId& objid) const {
01778     for (int i=0; i<OBJ_ID_SZ; i++) if (id[i] != objid.id[i]) return CmiFalse;
01779     return CmiTrue;
01780   }
01781 #endif
01782 } CmiObjId;
01783 
01784 /* public interface for thread id acquisition */
01785 CmiObjId *CthGetThreadID(CthThread th);
01786 void CthSetThreadID(CthThread th, int a, int b, int c);
01787 
01788 void CthTraceResume(CthThread t);
01789 
01790 /*FAULT_EVAC */
01791 #if CMK_BIGSIM_CHARM
01792 #define CmiNodeAlive(x) (1)
01793 #else
01794 CpvExtern(char *,_validProcessors);
01795 #define CmiNodeAlive(x)  (CpvAccess(_validProcessors)[x])
01796 #endif
01797 
01798 int CmiEndianness();
01799 
01800 #if CMK_CHARMDEBUG
01801 extern void setMemoryTypeChare(void*); /* for memory debugging */
01802 extern void setMemoryTypeMessage(void*); /* for memory debugging */
01803 #else
01804 #define setMemoryTypeChare(p) /* empty memory debugging method */
01805 #define setMemoryTypeMessage(p) /* empty memory debugging method */
01806 #endif
01807 
01808 #include "conv-cpm.h"
01809 #include "conv-cpath.h"
01810 #include "conv-qd.h"
01811 #include "conv-random.h"
01812 #include "conv-lists.h"
01813 #include "conv-trace.h"
01814 #include "persistent.h"
01815 #if CMK_CELL
01816 #include "cell-api.h"
01817 #endif
01818 #ifdef __ONESIDED_IMPL
01819 #include "conv-onesided.h"
01820 #endif
01821 
01822 /* The flag tells whether we are in the process of doing out-of-core emulation in BigSim */
01823 extern int _BgOutOfCoreFlag;
01824 extern int _BgInOutOfCoreMode;
01825 
01826 #ifdef ADAPT_SCHED_MEM
01827 extern int numMemCriticalEntries;
01828 extern int *memCriticalEntries;
01829 #endif
01830 
01831 double CmiReadSize(const char *str);
01832 
01833 #if  CMK_CONVERSE_GEMINI_UGNI
01834 void CmiTurnOnStats();
01835 void CmiTurnOffStats();
01836 #else
01837 #define CmiTurnOnStats()
01838 #define CmiTurnOffStats()
01839 #endif
01840 
01841 /* CharmLibInterOperate should be a global variable as it will be
01842  * set only once by MPI ranks respectively.
01843  */
01844 extern int CharmLibInterOperate;
01845 CpvExtern(int,charmLibExitFlag);
01846 
01847 /*
01848  *         Topology C wrapper
01849  */
01850 extern int CmiGetHopsBetweenRanks(int pe1, int pe2);
01851 
01852 #if defined(__cplusplus)
01853 }                                         /* end of extern "C"  */
01854 #endif
01855 
01856 #if CMK_GRID_QUEUE_AVAILABLE
01857 #if defined(__cplusplus)
01858 extern "C" int CmiGetCluster (int pe);
01859 extern "C" int CmiGridQueueGetInterval ();
01860 extern "C" int CmiGridQueueGetThreshold ();
01861 extern "C" void CmiGridQueueRegister (int gid, int nInts, int index1, int index2, int index3);
01862 extern "C" void CmiGridQueueDeregister (int gid, int nInts, int index1, int index2, int index3);
01863 extern "C" void CmiGridQueueDeregisterAll ();
01864 extern "C" int CmiGridQueueLookup (int gid, int nInts, int index1, int index2, int index3);
01865 extern "C" int CmiGridQueueLookupMsg (char *msg);
01866 #else
01867 extern int CmiGetCluster (int pe);
01868 extern int CmiGridQueueGetInterval ();
01869 extern int CmiGridQueueGetThreshold ();
01870 extern void CmiGridQueueRegister (int gid, int nInts, int index1, int index2, int index3);
01871 extern void CmiGridQueueDeregister (int gid, int nInts, int index1, int index2, int index3);
01872 extern void CmiGridQueueDeregisterAll ();
01873 extern int CmiGridQueueLookup (int gid, int nInts, int index1, int index2, int index3);
01874 extern int CmiGridQueueLookupMsg (char *msg);
01875 #endif
01876 #endif
01877 
01878 /******** I/O wrappers ***********/
01879 
01880 size_t CmiFwrite(const void *ptr, size_t size, size_t nmemb, FILE *f);
01881 FILE *CmiFopen(const char *path, const char *mode);
01882 int CmiFclose(FILE *fp);
01883 
01884 #include "debug-conv.h"
01885 
01886 typedef struct {
01887   CmiUInt4 msgSize;
01888   CmiUInt2 senderPe;
01889   CmiUInt2 destination;
01890 } CmiFragmentHeader;
01891 
01892 
01893 #if CMK_HAS_LOG2
01894 #define CmiLog2   log2
01895 #define CmiILog2  log2
01896 #else
01897 extern unsigned int CmiILog2(unsigned int);
01898 extern double CmiLog2(double);
01899 #endif
01900 
01901 #if CMK_SMP && CMK_LEVERAGE_COMMTHREAD
01902 #if defined(__cplusplus)
01903 #define EXTERN extern "C"
01904 #else
01905 #define EXTERN extern
01906 #endif
01907 typedef void (*CmiCommThdFnPtr)(int numParams, void *params);
01908 typedef struct CmiNotifyCommThdMsg {
01909     char core[CmiMsgHeaderSizeBytes];
01910     CmiCommThdFnPtr fn;
01911     int numParams;
01912     void *params;
01913     int toKeep; /* whether to free this msg by comm thread when the msg is processed */ 
01914 }CmiNotifyCommThdMsg;
01915 
01916 EXTERN CmiNotifyCommThdMsg *CmiCreateNotifyCommThdMsg(CmiCommThdFnPtr fn, int numParams, void *params, int toKeep);
01917 EXTERN void CmiFreeNotifyCommThdMsg(CmiNotifyCommThdMsg *msg);
01918 /* Initialize a notification msg */
01919 EXTERN void CmiResetNotifyCommThdMsg(CmiNotifyCommThdMsg *msg, CmiCommThdFnPtr fn, int numParams, void *params, int toKeep);
01920 /* Enqueue the msg into the local comm thread, and wait for being processed */
01921 EXTERN void CmiNotifyCommThd(CmiNotifyCommThdMsg *msg);
01922 #endif
01923 
01924 CpvCExtern(int, _urgentSend);
01925 #if CMK_USE_OOB
01926 #define CmiEnableUrgentSend(yn)   CpvAccess(_urgentSend)=(yn)
01927 #else
01928 #define CmiEnableUrgentSend(yn)   
01929 #endif
01930 
01931 #if defined(__cplusplus)
01932 extern "C" int CmiIsMyNodeIdle();
01933 #else
01934 extern int CmiIsMyNodeIdle();
01935 #endif
01936 
01937 #endif /* CONVERSE_H */
01938 
01939
conv-core/converse.h
