Labeled system global variable by underscore.
authorChao Huang <chuang10@uiuc.edu>
Fri, 12 Sep 2003 15:22:59 +0000 (15:22 +0000)
committerChao Huang <chuang10@uiuc.edu>
Fri, 12 Sep 2003 15:22:59 +0000 (15:22 +0000)
16 files changed:
src/arch/elan/machine.c
src/arch/exemplar/machine.c
src/arch/mpi/machine.c
src/arch/net/charmrun/charmrun.c
src/arch/net/machine-dgram.c
src/arch/net/machine-eth.c
src/arch/net/machine-gm.c
src/arch/net/machine-tcp.c
src/arch/net/machine.c
src/arch/origin-pthreads/machine.c
src/arch/origin2000/machine.c
src/arch/paragon/machine.c
src/arch/shmem/machine.c
src/arch/sim/machine.c
src/arch/sim/sim.c
src/arch/sp3/machine.c

index 8e35bbfc8286cbb63bd59c8ef0293fbb4fee694b..2386618832594162c319aa5fbb69060c26f7d553 100644 (file)
@@ -68,11 +68,11 @@ ELAN_EVENT *esmall[RECV_MSG_Q_SIZE], *emid[MID_MSG_Q_SIZE], *elarge;
 #define TAG_MID   0x10
 #define TAG_LARGE 0x100
 
-int Cmi_numpes;
-int               Cmi_mynode;    /* Which address space am I */
-int               Cmi_mynodesize;/* Number of processors in my address space */
-int               Cmi_numnodes;  /* Total number of address spaces */
-int               Cmi_numpes;    /* Total number of processors */
+int _Cmi_numpes;
+int               _Cmi_mynode;    /* Which address space am I */
+int               _Cmi_mynodesize;/* Number of processors in my address space */
+int               _Cmi_numnodes;  /* Total number of address spaces */
+int               _Cmi_numpes;    /* Total number of processors */
 static int        Cmi_nodestart; /* First processor in this address space */ 
 CpvDeclare(void*, CmiLocalQueue);
 
@@ -217,8 +217,8 @@ static PCQueue   msgBuf;
 CsvDeclare(CmiNodeState, NodeState);
 
 static struct CmiStateStruct Cmi_state;
-int Cmi_mype;
-int Cmi_myrank;
+int _Cmi_mype;
+int _Cmi_myrank;
 
 void CmiMemLock(void) {}
 void CmiMemUnlock(void) {}
@@ -229,8 +229,8 @@ void CmiMemUnlock(void) {}
 static void CmiStartThreads(char **argv)
 {
   CmiStateInit(Cmi_nodestart, 0, &Cmi_state);
-  Cmi_mype = Cmi_nodestart;
-  Cmi_myrank = 0;
+  _Cmi_mype = Cmi_nodestart;
+  _Cmi_myrank = 0;
 }      
 
 /*Add a message to this processor's receive queue */
@@ -265,13 +265,13 @@ int CmiMyRank(void)
 #endif
 
 #ifndef CmiNodeFirst
-int CmiNodeFirst(int node) { return node*Cmi_mynodesize; }
-int CmiNodeSize(int node)  { return Cmi_mynodesize; }
+int CmiNodeFirst(int node) { return node*_Cmi_mynodesize; }
+int CmiNodeSize(int node)  { return _Cmi_mynodesize; }
 #endif
 
 #ifndef CmiNodeOf
-int CmiNodeOf(int pe)      { return (pe/Cmi_mynodesize); }
-int CmiRankOf(int pe)      { return pe%Cmi_mynodesize; }
+int CmiNodeOf(int pe)      { return (pe/_Cmi_mynodesize); }
+int CmiRankOf(int pe)      { return pe%_Cmi_mynodesize; }
 #endif
 
 int CmiAllAsyncMsgsSent(void)
@@ -911,16 +911,16 @@ void SendSpanningChildren(int size, char *msg)
   int startpe = CMI_BROADCAST_ROOT(msg)-1;
   int i;
   
-  assert(startpe>=0 && startpe<Cmi_numpes);
+  assert(startpe>=0 && startpe<_Cmi_numpes);
 
   for (i=1; i<=BROADCAST_SPANNING_FACTOR; i++) {
     int p = cs->pe-startpe;
-    if (p<0) p+=Cmi_numpes;
+    if (p<0) p+=_Cmi_numpes;
     p = BROADCAST_SPANNING_FACTOR*p + i;
-    if (p > Cmi_numpes - 1) break;
+    if (p > _Cmi_numpes - 1) break;
     p += startpe;
-    p = p%Cmi_numpes;
-    assert(p>=0 && p<Cmi_numpes && p!=cs->pe);
+    p = p%_Cmi_numpes;
+    assert(p>=0 && p<_Cmi_numpes && p!=cs->pe);
     CmiSyncSendFn1(p, size, msg);
   }
 }
@@ -929,12 +929,12 @@ void CmiSyncBroadcastFn(int size, char *msg)     /* ALL_EXCEPT_ME  */
 {
   CmiState cs = CmiGetState();
 #if CMK_BROADCAST_SPANNING_TREE
-  CMI_SET_BROADCAST_ROOT(msg, Cmi_mype+1);
+  CMI_SET_BROADCAST_ROOT(msg, _Cmi_mype+1);
   SendSpanningChildren(size, msg);
 #else
   int i ;
      
-  for ( i=cs->pe+1; i<Cmi_numpes; i++ ) 
+  for ( i=cs->pe+1; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
   for ( i=0; i<cs->pe; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
@@ -947,7 +947,7 @@ CmiCommHandle CmiAsyncBroadcastFn(int size, char *msg)
   CmiState cs = CmiGetState();
   int i ;
 
-  for ( i=cs->pe+1; i<Cmi_numpes; i++ ) 
+  for ( i=cs->pe+1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
   for ( i=0; i<cs->pe; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
@@ -970,7 +970,7 @@ void CmiSyncBroadcastAllFn(int size, char *msg)        /* All including me */
 #else
   int i ;
   
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
 #endif
 }
@@ -979,7 +979,7 @@ CmiCommHandle CmiAsyncBroadcastAllFn(int size, char *msg)
 {
   int i ;
 
-  for ( i=1; i<Cmi_numpes; i++ ) 
+  for ( i=1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
   return (CmiCommHandle) (CmiAllAsyncMsgsSent());
 }
@@ -994,7 +994,7 @@ void CmiFreeBroadcastAllFn(int size, char *msg)  /* All including me */
 #else
   int i ;
      
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
 #endif
   CmiFree(msg) ;
@@ -1212,21 +1212,21 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   
   elan_gsync(elan_base->allGroup);
 
-  Cmi_numnodes = elan_base->state->nvp;
-  Cmi_mynode =  elan_base->state->vp;
+  _Cmi_numnodes = elan_base->state->nvp;
+  _Cmi_mynode =  elan_base->state->vp;
 
   /* processor per node */
-  Cmi_mynodesize = 1;
-  CmiGetArgInt(argv,"+ppn", &Cmi_mynodesize);
+  _Cmi_mynodesize = 1;
+  CmiGetArgInt(argv,"+ppn", &_Cmi_mynodesize);
 
-  if (Cmi_mynodesize > 1 && Cmi_mynode == 0) 
+  if (_Cmi_mynodesize > 1 && _Cmi_mynode == 0) 
     CmiAbort("+ppn cannot be used in non SMP version!\n");
   
-  Cmi_numpes = Cmi_numnodes * Cmi_mynodesize;
-  Cmi_nodestart = Cmi_mynode * Cmi_mynodesize;
+  _Cmi_numpes = _Cmi_numnodes * _Cmi_mynodesize;
+  Cmi_nodestart = _Cmi_mynode * _Cmi_mynodesize;
   Cmi_argv = argv; Cmi_startfn = fn; Cmi_usrsched = usched;
   /* find dim = log2(numpes), to pretend we are a hypercube */
-  for ( Cmi_dim=0,n=Cmi_numpes; n>1; n/=2 )
+  for ( Cmi_dim=0,n=_Cmi_numpes; n>1; n/=2 )
     Cmi_dim++ ;
  /* CmiSpanTreeInit();*/
   i=0;
index fdff7992b6ccb3782f3513586a0c00ef3b197b21..10204f954f01c2bdf2bce9b7cc8c5e93b37c7bd1 100644 (file)
@@ -30,7 +30,7 @@ static McQueue **MsgQueue;
 
 
 CpvDeclare(void*, CmiLocalQueue);
-node_private int Cmi_numpes;
+node_private int _Cmi_numpes;
 
 static node_private barrier_t barrier;
 
@@ -117,9 +117,9 @@ void ConverseInit(int argc, char** argv, CmiStartFn fn, int usched, int initret)
 
     /* figure out number of processors required */
     i =  0;
-    Cmi_numpes = 0; 
-    CmiGetArgInt(argv,"+p",&Cmi_numpes);
-    if (Cmi_numpes <= 0)
+    _Cmi_numpes = 0; 
+    CmiGetArgInt(argv,"+p",&_Cmi_numpes);
+    if (_Cmi_numpes <= 0)
       CmiAbort("Invalid number of processors\n");
 
     Cmi_argc = argc;
@@ -129,18 +129,18 @@ void ConverseInit(int argc, char** argv, CmiStartFn fn, int usched, int initret)
     Cmi_initret = initret;
 
     request.node = CPS_SAME_NODE;
-    request.min  = Cmi_numpes;
-    request.max  = Cmi_numpes;
+    request.min  = _Cmi_numpes;
+    request.max  = _Cmi_numpes;
     request.threadscope = CPS_THREAD_PARALLEL;
    
     if(cps_barrier_alloc(&barrier)!=0)
       CmiAbort("Cannot Alocate Barrier\n");
 
-    MsgQueue=(McQueue **)g_malloc(Cmi_numpes*sizeof(McQueue *));
+    MsgQueue=(McQueue **)g_malloc(_Cmi_numpes*sizeof(McQueue *));
     if (MsgQueue == (McQueue **)0) {
        CmiAbort("Cannot Allocate Memory...\n");
     }
-    for(i=0; i<Cmi_numpes; i++) MsgQueue[i] = McQueueCreate();
+    for(i=0; i<_Cmi_numpes; i++) MsgQueue[i] = McQueueCreate();
 
     if (cps_ppcall(&request, threadInit ,(void *) 0) < 0) {
        CmiAbort("Cannot create threads...\n");
@@ -152,7 +152,7 @@ void ConverseInit(int argc, char** argv, CmiStartFn fn, int usched, int initret)
 void ConverseExit(void)
 {
    ConverseCommonExit();
-   cps_barrier(&barrier,&Cmi_numpes);
+   cps_barrier(&barrier,&_Cmi_numpes);
 }
 
 static void threadInit(arg)
@@ -268,7 +268,7 @@ void CmiFreeBroadcastAllFn(int size, char *msg)
 
 void CmiNodeBarrier()
 {
-   if(cps_barrier(&barrier,&Cmi_numpes)!=0)
+   if(cps_barrier(&barrier,&_Cmi_numpes)!=0)
      CmiAbort("Error in Barrier\n");
 }
 
index 21192a9204d930c3e008593f03202cb5f584dd9b..1cd46c7186a714857b8cb81d01c2d1061a46b8ff 100644 (file)
 
 #define TAG     1375
 
-int Cmi_numpes;
-int               Cmi_mynode;    /* Which address space am I */
-int               Cmi_mynodesize;/* Number of processors in my address space */
-int               Cmi_numnodes;  /* Total number of address spaces */
-int               Cmi_numpes;    /* Total number of processors */
+int _Cmi_numpes;
+int               _Cmi_mynode;    /* Which address space am I */
+int               _Cmi_mynodesize;/* Number of processors in my address space */
+int               _Cmi_numnodes;  /* Total number of address spaces */
+int               _Cmi_numpes;    /* Total number of processors */
 static int        Cmi_nodestart; /* First processor in this address space */ 
 CpvDeclare(void*, CmiLocalQueue);
 
@@ -229,8 +229,8 @@ CsvDeclare(CmiNodeState, NodeState);
 #if ! CMK_SMP
 /************ non SMP **************/
 static struct CmiStateStruct Cmi_state;
-int Cmi_mype;
-int Cmi_myrank;
+int _Cmi_mype;
+int _Cmi_myrank;
 
 void CmiMemLock(void) {}
 void CmiMemUnlock(void) {}
@@ -243,8 +243,8 @@ void CmiYield(void) { sleep(0); }
 static void CmiStartThreads(char **argv)
 {
   CmiStateInit(Cmi_nodestart, 0, &Cmi_state);
-  Cmi_mype = Cmi_nodestart;
-  Cmi_myrank = 0;
+  _Cmi_mype = Cmi_nodestart;
+  _Cmi_myrank = 0;
 }      
 #endif /* non smp */
 
@@ -314,13 +314,13 @@ int CmiMyRank(void)
 #endif
 
 #ifndef CmiNodeFirst
-int CmiNodeFirst(int node) { return node*Cmi_mynodesize; }
-int CmiNodeSize(int node)  { return Cmi_mynodesize; }
+int CmiNodeFirst(int node) { return node*_Cmi_mynodesize; }
+int CmiNodeSize(int node)  { return _Cmi_mynodesize; }
 #endif
 
 #ifndef CmiNodeOf
-int CmiNodeOf(int pe)      { return (pe/Cmi_mynodesize); }
-int CmiRankOf(int pe)      { return pe%Cmi_mynodesize; }
+int CmiNodeOf(int pe)      { return (pe/_Cmi_mynodesize); }
+int CmiRankOf(int pe)      { return pe%_Cmi_mynodesize; }
 #endif
 
 static int CmiAllAsyncMsgsSent(void)
@@ -494,7 +494,7 @@ static int MsgQueueEmpty()
 {
   int i;
 #if 0
-  for (i=0; i<Cmi_mynodesize; i++)
+  for (i=0; i<_Cmi_mynodesize; i++)
     if (!PCQueueEmpty(procState[i].sendMsgBuf)) return 0;
 #else
   return PCQueueEmpty(sendMsgBuf);
@@ -508,7 +508,7 @@ static int SendMsgBuf();
 static int RecvQueueEmpty()
 {
   int i;
-  for (i=0; i<Cmi_mynodesize; i++) {
+  for (i=0; i<_Cmi_mynodesize; i++) {
     CmiState cs=CmiGetStateN(i);
     if (!PCQueueEmpty(cs->recv)) return 0;
   }
@@ -672,7 +672,7 @@ static int SendMsgBuf()
 
   MACHSTATE(2,"SendMsgBuf begin {");
 #if 0
-  for (i=0; i<Cmi_mynodesize; i++)
+  for (i=0; i<_Cmi_mynodesize; i++)
   {
     while (!PCQueueEmpty(procState[i].sendMsgBuf))
     {
@@ -812,16 +812,16 @@ void SendSpanningChildren(int size, char *msg)
   int startpe = CMI_BROADCAST_ROOT(msg)-1;
   int i;
 
-  assert(startpe>=0 && startpe<Cmi_numpes);
+  assert(startpe>=0 && startpe<_Cmi_numpes);
 
   for (i=1; i<=BROADCAST_SPANNING_FACTOR; i++) {
     int p = cs->pe-startpe;
-    if (p<0) p+=Cmi_numpes;
+    if (p<0) p+=_Cmi_numpes;
     p = BROADCAST_SPANNING_FACTOR*p + i;
-    if (p > Cmi_numpes - 1) break;
+    if (p > _Cmi_numpes - 1) break;
     p += startpe;
-    p = p%Cmi_numpes;
-    assert(p>=0 && p<Cmi_numpes && p!=cs->pe);
+    p = p%_Cmi_numpes;
+    assert(p>=0 && p<_Cmi_numpes && p!=cs->pe);
     CmiSyncSendFn1(p, size, msg);
   }
 }
@@ -841,7 +841,7 @@ void SendHypercube(int size, char *msg)
   
   /*  CmiPrintf("In hypercube\n"); */
 
-  /* assert(startpe>=0 && startpe<Cmi_numpes); */
+  /* assert(startpe>=0 && startpe<_Cmi_numpes); */
 
   for (i = curcycle; i < logp; i++) {
     int p = cs->pe ^ (1 << i);
@@ -858,7 +858,7 @@ void SendHypercube(int size, char *msg)
 void CmiSyncBroadcastFn(int size, char *msg)     /* ALL_EXCEPT_ME  */
 {
 #if CMK_BROADCAST_SPANNING_TREE
-  CMI_SET_BROADCAST_ROOT(msg, Cmi_mype+1);
+  CMI_SET_BROADCAST_ROOT(msg, _Cmi_mype+1);
   SendSpanningChildren(size, msg);
   
 #elif CMK_BROADCAST_HYPERCUBE
@@ -869,7 +869,7 @@ void CmiSyncBroadcastFn(int size, char *msg)     /* ALL_EXCEPT_ME  */
   CmiState cs = CmiGetState();
   int i;
 
-  for ( i=cs->pe+1; i<Cmi_numpes; i++ ) 
+  for ( i=cs->pe+1; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
   for ( i=0; i<cs->pe; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
@@ -885,7 +885,7 @@ CmiCommHandle CmiAsyncBroadcastFn(int size, char *msg)
   CmiState cs = CmiGetState();
   int i ;
 
-  for ( i=cs->pe+1; i<Cmi_numpes; i++ ) 
+  for ( i=cs->pe+1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
   for ( i=0; i<cs->pe; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
@@ -919,7 +919,7 @@ void CmiSyncBroadcastAllFn(int size, char *msg)        /* All including me */
 #else
     int i ;
      
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
 #endif
 
@@ -930,7 +930,7 @@ CmiCommHandle CmiAsyncBroadcastAllFn(int size, char *msg)
 {
   int i ;
 
-  for ( i=1; i<Cmi_numpes; i++ ) 
+  for ( i=1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
 
   CmiAbort("In  AsyncBroadcastAll broadcast\n");
@@ -956,7 +956,7 @@ void CmiFreeBroadcastAllFn(int size, char *msg)  /* All including me */
 #else
   int i ;
      
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
 #endif
   CmiFree(msg) ;
@@ -979,16 +979,16 @@ CmiCommHandle CmiAsyncNodeSendFn(int dstNode, int size, char *msg)
     PCQueuePush(CsvAccess(NodeState).NodeRecv,(char *)CopyMsg(msg,size));
     CmiUnlock(CsvAccess(NodeState).CmiNodeRecvLock);
   case NODE_BROADCAST_OTHERS:
-    CQdCreate(CpvAccess(cQdState), Cmi_numnodes-1);
-    for (i=0; i<Cmi_numnodes; i++)
-      if (i!=Cmi_mynode) {
+    CQdCreate(CpvAccess(cQdState), _Cmi_numnodes-1);
+    for (i=0; i<_Cmi_numnodes; i++)
+      if (i!=_Cmi_mynode) {
         EnqueueMsg((char *)CopyMsg(msg,size), size, i);
       }
     break;
   default:
     CQdCreate(CpvAccess(cQdState), 1);
     dupmsg = (char *)CopyMsg(msg,size);
-    if(dstNode == Cmi_mynode) {
+    if(dstNode == _Cmi_mynode) {
       CmiLock(CsvAccess(NodeState).CmiNodeRecvLock);
       PCQueuePush(CsvAccess(NodeState).NodeRecv, dupmsg);
       CmiUnlock(CsvAccess(NodeState).CmiNodeRecvLock);
@@ -1195,33 +1195,33 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
 #endif
   
   PMPI_Init(&argc, &argv);
-  PMPI_Comm_size(MPI_COMM_WORLD, &Cmi_numnodes);
-  PMPI_Comm_rank(MPI_COMM_WORLD, &Cmi_mynode);
+  PMPI_Comm_size(MPI_COMM_WORLD, &_Cmi_numnodes);
+  PMPI_Comm_rank(MPI_COMM_WORLD, &_Cmi_mynode);
   /* processor per node */
-  Cmi_mynodesize = 1;
-  CmiGetArgInt(argv,"+ppn", &Cmi_mynodesize);
+  _Cmi_mynodesize = 1;
+  CmiGetArgInt(argv,"+ppn", &_Cmi_mynodesize);
 #if ! CMK_SMP
-  if (Cmi_mynodesize > 1 && Cmi_mynode == 0) 
+  if (_Cmi_mynodesize > 1 && _Cmi_mynode == 0) 
     CmiAbort("+ppn cannot be used in non SMP version!\n");
 #endif
   idleblock = CmiGetArgFlag(argv, "+idleblocking");
-  if (idleblock && Cmi_mynode == 0) {
+  if (idleblock && _Cmi_mynode == 0) {
     CmiPrintf("Charm++: Running in idle blocking mode.\n");
   }
 
 #if CMK_NO_OUTSTANDING_SENDS
   no_outstanding_sends=1;
 #endif
-  if (CmiGetArgInt(argv,"+no_outstanding_sends",&no_outstanding_sends) && Cmi_mynode == 0) {
+  if (CmiGetArgInt(argv,"+no_outstanding_sends",&no_outstanding_sends) && _Cmi_mynode == 0) {
      CmiPrintf("Charm++: Will%s consume outstanding sends in scheduler loop\n",
        no_outstanding_sends?"":" not");
   }
-  Cmi_numpes = Cmi_numnodes * Cmi_mynodesize;
-  Cmi_nodestart = Cmi_mynode * Cmi_mynodesize;
+  _Cmi_numpes = _Cmi_numnodes * _Cmi_mynodesize;
+  Cmi_nodestart = _Cmi_mynode * _Cmi_mynodesize;
   Cmi_argvcopy = CmiCopyArgs(argv);
   Cmi_argv = argv; Cmi_startfn = fn; Cmi_usrsched = usched;
   /* find dim = log2(numpes), to pretend we are a hypercube */
-  for ( Cmi_dim=0,n=Cmi_numpes; n>1; n/=2 )
+  for ( Cmi_dim=0,n=_Cmi_numpes; n>1; n/=2 )
     Cmi_dim++ ;
  /* CmiSpanTreeInit();*/
   request_max=MAX_QLEN;
@@ -1229,7 +1229,7 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   /*printf("request max=%d\n", request_max);*/
   if (CmiGetArgFlag(argv,"++debug"))
   {   /*Pause so user has a chance to start and attach debugger*/
-    printf("CHARMDEBUG> Processor %d has PID %d\n",Cmi_mynode,getpid());
+    printf("CHARMDEBUG> Processor %d has PID %d\n",_Cmi_mynode,getpid());
     if (!CmiGetArgFlag(argv,"++debug-no-pause"))
       sleep(10);
   }
@@ -1250,8 +1250,8 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   CsvInitialize(CmiNodeState, NodeState);
   CmiNodeStateInit(&CsvAccess(NodeState));
 
-  procState = (ProcState *)malloc((Cmi_mynodesize+1) * sizeof(ProcState));
-  for (i=0; i<Cmi_mynodesize+1; i++) {
+  procState = (ProcState *)malloc((_Cmi_mynodesize+1) * sizeof(ProcState));
+  for (i=0; i<_Cmi_mynodesize+1; i++) {
 /*    procState[i].sendMsgBuf = PCQueueCreate();   */
     procState[i].recvLock = CmiCreateLock();
   }
index 08aa169e9161258bd81d9c3217970231a4e4a0aa..cdd0becf262e1ed70faf8eb147c50827ed62c1c2 100644 (file)
@@ -813,7 +813,7 @@ int           nodetab_rank0_size;
 void nodetab_reset(nodetab_host *h)
 {
   h->name="SET_H->NAME";
-  h->ip=skt_invalid_ip;
+  h->ip=_skt_invalid_ip;
   h->pathfixes = 0;
   h->ext = "*";
   h->speed = 1.0;
@@ -850,7 +850,7 @@ void nodetab_makehost(char *name,nodetab_host *h)
 {
   h->name=strdup(name);
   h->ip = skt_innode_lookup_ip(name);
-  if (skt_ip_match(h->ip,skt_invalid_ip)) {
+  if (skt_ip_match(h->ip,_skt_invalid_ip)) {
     fprintf(stderr,"ERROR> Cannot obtain IP address of %s\n", name);
     exit(1);
   }
index d715d1e012bce7df6dcf43a493af6980698f835f..888d55065a024ba0a26212ddb5afaf4751ed9af4 100644 (file)
@@ -308,21 +308,21 @@ static void node_addresses_store(ChMessage *msg)
   ChNodeinfo *d=(ChNodeinfo *)(n32+1);
   int nodestart;
   int i,j,n;
-  Cmi_numnodes=ChMessageInt(n32[0]);
+  _Cmi_numnodes=ChMessageInt(n32[0]);
   
-  if ((sizeof(ChMessageInt_t)+sizeof(ChNodeinfo)*Cmi_numnodes)
+  if ((sizeof(ChMessageInt_t)+sizeof(ChNodeinfo)*_Cmi_numnodes)
          !=(unsigned int)msg->len)
     {printf("Node table has inconsistent length!");machine_exit(1);}
-  nodes = (OtherNode)malloc(Cmi_numnodes * sizeof(struct OtherNodeStruct));
+  nodes = (OtherNode)malloc(_Cmi_numnodes * sizeof(struct OtherNodeStruct));
   nodestart=0;
-  for (i=0; i<Cmi_numnodes; i++) {
+  for (i=0; i<_Cmi_numnodes; i++) {
     nodes[i].nodestart = nodestart;
     nodes[i].nodesize  = ChMessageInt(d[i].nPE);
     nodes[i].mach_id = ChMessageInt(d[i].mach_id);
     nodes[i].IP=d[i].IP;
-    if (i==Cmi_mynode) {
+    if (i==_Cmi_mynode) {
       Cmi_nodestart=nodes[i].nodestart;
-      Cmi_mynodesize=nodes[i].nodesize;
+      _Cmi_mynodesize=nodes[i].nodesize;
       Cmi_self_IP=nodes[i].IP;
     }
     nodes[i].dataport = ChMessageInt(d[i].dataport);
@@ -335,14 +335,14 @@ static void node_addresses_store(ChMessage *msg)
 #endif
     nodestart+=nodes[i].nodesize;
   }
-  Cmi_numpes=nodestart;
-  n = Cmi_numpes;
+  _Cmi_numpes=nodestart;
+  n = _Cmi_numpes;
 #ifdef CMK_CPV_IS_SMP
-  n += Cmi_numnodes;
+  n += _Cmi_numnodes;
 #endif
   nodes_by_pe = (OtherNode*)malloc(n * sizeof(OtherNode));
   _MEMCHECK(nodes_by_pe);
-  for (i=0; i<Cmi_numnodes; i++) {
+  for (i=0; i<_Cmi_numnodes; i++) {
     OtherNode node = nodes + i;
     OtherNode_init(node);
     for (j=0; j<node->nodesize; j++)
@@ -350,8 +350,8 @@ static void node_addresses_store(ChMessage *msg)
   }
 #ifdef CMK_CPV_IS_SMP
   /* index for communication threads */
-  for (i=Cmi_numpes; i<Cmi_numpes+Cmi_numnodes; i++) {
-    OtherNode node = nodes + i-Cmi_numpes;
+  for (i=_Cmi_numpes; i<_Cmi_numpes+_Cmi_numnodes; i++) {
+    OtherNode node = nodes + i-_Cmi_numpes;
     nodes_by_pe[i] = node;
   }
 #endif
index 16435eb44364422212128507b18f6f2382d52cc9..686b017cc4db54616efb4c8c1d0bdf6ed56a5372 100644 (file)
@@ -219,9 +219,9 @@ void TransmitImplicitDgram1(ImplicitDgram dg)
 int TransmitAcknowledgement()
 {
   int skip; static int nextnode=0; OtherNode node;
-  for (skip=0; skip<Cmi_numnodes; skip++) {
+  for (skip=0; skip<_Cmi_numnodes; skip++) {
     node = nodes+nextnode;
-    nextnode = (nextnode + 1) % Cmi_numnodes;
+    nextnode = (nextnode + 1) % _Cmi_numnodes;
     if (node->recv_ack_cnt) {
       if ((node->recv_ack_cnt > Cmi_half_window) ||
          (Cmi_clock >= node->recv_ack_time)) {
@@ -254,9 +254,9 @@ int TransmitDatagram()
   static int nextnode=0; int skip, count, slot;
   unsigned int seqno;
   
-  for (skip=0; skip<Cmi_numnodes; skip++) {
+  for (skip=0; skip<_Cmi_numnodes; skip++) {
     node = nodes+nextnode;
-    nextnode = (nextnode + 1) % Cmi_numnodes;
+    nextnode = (nextnode + 1) % _Cmi_numnodes;
     dg = node->send_queue_h;
     if (dg) {
       seqno = dg->seqno;
@@ -379,7 +379,7 @@ void AssembleDatagram(OtherNode node, ExplicitDgram dg)
        dg->seqno,node->nodestart,size)
     msg = (char *)CmiAlloc(size);
     if (!msg)
-      fprintf(stderr, "%d: Out of mem\n", Cmi_mynode);
+      fprintf(stderr, "%d: Out of mem\n", _Cmi_mynode);
     if (size < dg->len) KillEveryoneCode(4559312);
     memcpy(msg, (char*)(dg->data), dg->len);
     node->asm_rank = dg->rank;
@@ -401,7 +401,7 @@ void AssembleDatagram(OtherNode node, ExplicitDgram dg)
   if (node->asm_fill == node->asm_total) {
     if (node->asm_rank == DGRAM_BROADCAST) {
       int len = node->asm_total;
-      for (i=1; i<Cmi_mynodesize; i++)
+      for (i=1; i<_Cmi_mynodesize; i++)
          CmiPushPE(i, CopyMsg(msg, len));
       CmiPushPE(0, msg);
     } else {
index cde4f56b6a0920a0f6bf799054e748fe7e361102..3b4510fc5086f6b8dd36f3b00ebe763566e1b59b 100644 (file)
@@ -277,7 +277,7 @@ static void processMessage(char *msg, int len)
         size = CmiMsgHeaderGetLength(msg);
         newmsg = (char *)CmiAlloc(size);
         if (!newmsg)
-          fprintf(stderr, "%d: Out of mem\n", Cmi_mynode);
+          fprintf(stderr, "%d: Out of mem\n", _Cmi_mynode);
         if (size < len) KillEveryoneCode(4559312);
         memcpy(newmsg, msg, len);
         node->asm_rank = rank;
@@ -293,7 +293,7 @@ static void processMessage(char *msg, int len)
          CmiAbort("\n\n\t\tLength mismatch!!\n\n");
       if (node->asm_fill == node->asm_total) {
         if (rank == DGRAM_BROADCAST) {
-          for (i=1; i<Cmi_mynodesize; i++)
+          for (i=1; i<_Cmi_mynodesize; i++)
             CmiPushPE(i, CopyMsg(newmsg, len));
           CmiPushPE(0, newmsg);
         } else {
@@ -481,7 +481,7 @@ void CmiMachineInit()
   device = 0;
   for (dataport=2;dataport<dataport_max;dataport++) {
     char portname[200];
-    sprintf(portname, "converse_port%d_%d", Cmi_charmrun_pid, Cmi_mynode);
+    sprintf(portname, "converse_port%d_%d", Cmi_charmrun_pid, _Cmi_mynode);
     status = gm_open(&gmport, device, dataport, portname, GM_API_VERSION_1_1);
     if (status == GM_SUCCESS) { break; }
   }
@@ -543,7 +543,7 @@ void CmiCheckGmStatus()
   int i;
   int doabort = 0;
   if (gmport == NULL) machine_exit(1);
-  for (i=0; i<Cmi_numnodes; i++) {
+  for (i=0; i<_Cmi_numnodes; i++) {
     gm_status_t status;
     char uid[6], str[100];
     unsigned int mach_id=nodes[i].mach_id;
index a5657dc1c8bca33500b9c0fabf572922b87a2f7c..5044e475c3fe4f43bebd879ab95f535b00aa9b3c 100644 (file)
@@ -213,7 +213,7 @@ here-- WSAEINVAL, WSAENOTSOCK-- yet everything is actually OK.
     if (Cmi_charmrun_fd!=-1)
        ctrlskt_ready_read = CMK_PIPE_CHECKREAD(Cmi_charmrun_fd);
     if (dataskt!=-1) {
-      for (i=0; i<Cmi_numnodes; i++)
+      for (i=0; i<_Cmi_numnodes; i++)
       {
         if (i == CmiMyNode()) continue;
         if (nodes[i].send_queue_h) {
@@ -345,7 +345,7 @@ static void IntegrateMessageDatagram(char **msg, int len)
        else {
           newmsg = (char *)CmiAlloc(size);
           if (!newmsg)
-            fprintf(stderr, "%d: Out of mem\n", Cmi_mynode);
+            fprintf(stderr, "%d: Out of mem\n", _Cmi_mynode);
           memcpy(newmsg, *msg, len);
          freeMaxBuf(*msg);             /* free buffer, must be max size */
        }
@@ -368,7 +368,7 @@ static void IntegrateMessageDatagram(char **msg, int len)
          CmiAbort("\n\n\t\tLength mismatch!!\n\n");
       if (node->asm_fill == node->asm_total) {
         if (rank == DGRAM_BROADCAST) {
-          for (i=1; i<Cmi_mynodesize; i++)
+          for (i=1; i<_Cmi_mynodesize; i++)
             CmiPushPE(i, CopyMsg(newmsg, node->asm_total));
           CmiPushPE(0, newmsg);
         } else {
@@ -565,8 +565,8 @@ static void open_tcp_sockets()
   SOCKET skt;
   int val;
 
-  mype = Cmi_mynode;
-  numpes = Cmi_numnodes;
+  mype = _Cmi_mynode;
+  numpes = _Cmi_numnodes;
   MACHSTATE2(2,"  open_tcp_sockets (%d:%d)", mype, numpes);
   for (i=0; i<mype; i++) {
     unsigned int clientPort;
index 36487e4fb15d7d0c86a31c4cc8eeba1b649070c6..045fbd224b23761955201df50482707385678f33 100644 (file)
@@ -560,10 +560,10 @@ void CmiEnableNonblockingIO(int fd) { }
  *
  *****************************************************************************/
 
-int               Cmi_mynode;    /* Which address space am I */
-int               Cmi_mynodesize;/* Number of processors in my address space */
-int               Cmi_numnodes;  /* Total number of address spaces */
-int               Cmi_numpes;    /* Total number of processors */
+int               _Cmi_mynode;    /* Which address space am I */
+int               _Cmi_mynodesize;/* Number of processors in my address space */
+int               _Cmi_numnodes;  /* Total number of address spaces */
+int               _Cmi_numpes;    /* Total number of processors */
 static int        Cmi_nodestart; /* First processor in this address space */
 static skt_ip_t   Cmi_self_IP;
 static skt_ip_t   Cmi_charmrun_IP; /*Address of charmrun machine*/
@@ -586,7 +586,7 @@ static void parse_netstart(void)
   {/*Read values set by Charmrun*/
         char Cmi_charmrun_name[1024];
         nread = sscanf(ns, "%d%s%d%d%d",
-                 &Cmi_mynode,
+                 &_Cmi_mynode,
                  Cmi_charmrun_name, &Cmi_charmrun_port,
                  &Cmi_charmrun_pid, &port);
        Cmi_charmrun_IP=skt_lookup_ip(Cmi_charmrun_name);
@@ -597,8 +597,8 @@ static void parse_netstart(void)
         }
   } else 
   {/*No charmrun-- set flag values for standalone operation*/
-       Cmi_mynode=0;
-       Cmi_charmrun_IP=skt_invalid_ip;
+       _Cmi_mynode=0;
+       Cmi_charmrun_IP=_skt_invalid_ip;
        Cmi_charmrun_port=0;
        Cmi_charmrun_pid=0;
         dataport = -1;
@@ -657,7 +657,7 @@ static void log_init(void)
 static void log_done(void)
 {
   char logname[100]; FILE *f; int i, size;
-  sprintf(logname, "log.%d", Cmi_mynode);
+  sprintf(logname, "log.%d", _Cmi_mynode);
   f = fopen(logname, "w");
   if (f==0) KillEveryone("fopen problem");
   if (log_wrap) size = 50000; else size=log_pos;
@@ -676,8 +676,8 @@ void printLog(void)
   if (logged)
       return;
   logged = 1;
-  CmiPrintf("Logging: %d\n", Cmi_mynode);
-  sprintf(logname, "log.%d", Cmi_mynode);
+  CmiPrintf("Logging: %d\n", _Cmi_mynode);
+  sprintf(logname, "log.%d", _Cmi_mynode);
   f = fopen(logname, "w");
   if (f==0) KillEveryone("fopen problem");
   for (i = 5000; i; i--)
@@ -698,7 +698,7 @@ void printLog(void)
     }
   }
   fclose(f);
-  CmiPrintf("Done Logging: %d\n", Cmi_mynode);
+  CmiPrintf("Done Logging: %d\n", _Cmi_mynode);
 }
 
 #define LOG(t,s,k,d,q) { if (log_pos==50000) { log_pos=0; log_wrap=1;} { logent ent=log+log_pos; ent->time=t; ent->srcpe=s; ent->kind=k; ent->dstpe=d; ent->seqno=q; log_pos++; }}
@@ -755,8 +755,8 @@ void CmiCommUnlock(void) {
 #endif
 
 static struct CmiStateStruct Cmi_state;
-int Cmi_mype;
-int Cmi_myrank=0; /* Normally zero; only 1 during SIGIO handling */
+int _Cmi_mype;
+int _Cmi_myrank=0; /* Normally zero; only 1 during SIGIO handling */
 #define CmiGetState() (&Cmi_state)
 #define CmiGetStateN(n) (&Cmi_state)
 
@@ -764,8 +764,8 @@ void CmiYield(void) { sleep(0); }
 
 static void CommunicationInterrupt(int ignored)
 {
-  MACHLOCK_ASSERT(!Cmi_myrank,"CommunicationInterrupt");
-  if (memflag || comm_flag || immRunning) 
+  MACHLOCK_ASSERT(!_Cmi_myrank,"CommunicationInterrupt");
+  if (memflag || comm_flag || _immRunning) 
   { /* Already busy inside malloc, comm, or immediate messages */
     MACHSTATE(5,"--SKIPPING SIGIO--");
     return;
@@ -774,9 +774,9 @@ static void CommunicationInterrupt(int ignored)
   {
     /*Make sure any malloc's we do in here are NOT migratable:*/
     CmiIsomallocBlockList *oldList=CmiIsomallocBlockListActivate(NULL);
-/*    Cmi_myrank=1; */
+/*    _Cmi_myrank=1; */
     CommunicationServerThread(0);
-/*    Cmi_myrank=0; */
+/*    _Cmi_myrank=0; */
     CmiIsomallocBlockListActivate(oldList);
   }
   MACHSTATE(2,"--END SIGIO--")
@@ -786,17 +786,17 @@ extern void CmiSignal(int sig1, int sig2, int sig3, void (*handler)());
 
 static void CmiStartThreads(char **argv)
 {
-  if ((Cmi_numpes != Cmi_numnodes) || (Cmi_mynodesize != 1))
+  if ((_Cmi_numpes != _Cmi_numnodes) || (_Cmi_mynodesize != 1))
     KillEveryone
       ("Multiple cpus unavailable, don't use cpus directive in nodesfile.\n");
   
   CmiStateInit(Cmi_nodestart, 0, &Cmi_state);
-  Cmi_mype = Cmi_nodestart;
+  _Cmi_mype = Cmi_nodestart;
 
   /* Prepare Cpv's for immediate messages: */
-  Cmi_myrank=1;
+  _Cmi_myrank=1;
   CommunicationServerInit();
-  Cmi_myrank=0;
+  _Cmi_myrank=0;
   
 #if !CMK_ASYNC_NOT_NEEDED
   if (!Cmi_netpoll) {
@@ -1357,18 +1357,18 @@ static void node_addresses_obtain(char **argv)
        fakeTab->nodeNo=ChMessageInt_new(1); /* <- hack */
        fakeTab->info.nPE=ChMessageInt_new(npes);
        fakeTab->info.dataport=ChMessageInt_new(0);
-       fakeTab->info.IP=skt_invalid_ip;
+       fakeTab->info.IP=_skt_invalid_ip;
   }
   else 
   { /*Contact charmrun for machine info.*/
        ChSingleNodeinfo me;
 
-       me.nodeNo=ChMessageInt_new(Cmi_mynode);
+       me.nodeNo=ChMessageInt_new(_Cmi_mynode);
        /*The nPE and IP fields are set by charmrun--
          these values don't matter.
        */
        me.info.nPE=ChMessageInt_new(0);
-       me.info.IP=skt_invalid_ip;
+       me.info.IP=_skt_invalid_ip;
        me.info.mach_id=ChMessageInt_new(Cmi_mach_id);
        me.info.dataport=ChMessageInt_new(dataport);
 
@@ -1408,15 +1408,15 @@ void DeliverOutgoingNodeMessage(OutgoingMsg ogm)
     CmiPushNode(CopyMsg(ogm->data,ogm->size));
     /*case-fallthrough (no break)-- deliver to all other processors*/
   case NODE_BROADCAST_OTHERS:
-    for (i=0; i<Cmi_numnodes; i++)
-      if (i!=Cmi_mynode)
+    for (i=0; i<_Cmi_numnodes; i++)
+      if (i!=_Cmi_mynode)
        DeliverViaNetwork(ogm, nodes + i, DGRAM_NODEMESSAGE);
     GarbageCollectMsg(ogm);
     break;
   default:
     node = nodes+dst;
     rank=DGRAM_NODEMESSAGE;
-    if (dst != Cmi_mynode) {
+    if (dst != _Cmi_mynode) {
       DeliverViaNetwork(ogm, node, rank);
       GarbageCollectMsg(ogm);
     } else {
@@ -1454,21 +1454,21 @@ void DeliverOutgoingMessage(OutgoingMsg ogm)
   dst = ogm->dst;
   switch (dst) {
   case PE_BROADCAST_ALL:
-    for (rank = 0; rank<Cmi_mynodesize; rank++) {
+    for (rank = 0; rank<_Cmi_mynodesize; rank++) {
       CmiPushPE(rank,CopyMsg(ogm->data,ogm->size));
     }
-    for (i=0; i<Cmi_numnodes; i++)
-      if (i!=Cmi_mynode)
+    for (i=0; i<_Cmi_numnodes; i++)
+      if (i!=_Cmi_mynode)
        DeliverViaNetwork(ogm, nodes + i, DGRAM_BROADCAST);
     GarbageCollectMsg(ogm);
     break;
   case PE_BROADCAST_OTHERS:
-    for (rank = 0; rank<Cmi_mynodesize; rank++)
+    for (rank = 0; rank<_Cmi_mynodesize; rank++)
       if (rank + Cmi_nodestart != ogm->src) {
        CmiPushPE(rank,CopyMsg(ogm->data,ogm->size));
       }
-    for (i = 0; i<Cmi_numnodes; i++)
-      if (i!=Cmi_mynode)
+    for (i = 0; i<_Cmi_numnodes; i++)
+      if (i!=_Cmi_mynode)
        DeliverViaNetwork(ogm, nodes + i, DGRAM_BROADCAST);
     GarbageCollectMsg(ogm);
     break;
@@ -1568,7 +1568,7 @@ CmiCommHandle CmiGeneralNodeSend(int pe, int size, int freemode, char *data)
   if (freemode == 'S') {
     char *copy = (char *)CmiAlloc(size);
     if (!copy)
-      fprintf(stderr, "%d: Out of mem\n", Cmi_mynode);
+      fprintf(stderr, "%d: Out of mem\n", _Cmi_mynode);
     memcpy(copy, data, size);
     data = copy; freemode = 'F';
   }
@@ -1604,13 +1604,13 @@ CmiCommHandle CmiGeneralSend(int pe, int size, int freemode, char *data)
   if (freemode == 'S') {
     char *copy = (char *)CmiAlloc(size);
     if (!copy)
-      fprintf(stderr, "%d: Out of mem\n", Cmi_mynode);
+      fprintf(stderr, "%d: Out of mem\n", _Cmi_mynode);
     memcpy(copy, data, size);
     data = copy; freemode = 'F';
   }
   if (pe == cs->pe) 
 #if ! CMK_SMP
-  if (!immRunning) /* CdsFifo_Enqueue, below, isn't SIGIO or thread safe.  
+  if (!_immRunning) /* CdsFifo_Enqueue, below, isn't SIGIO or thread safe.  
                       The SMP comm thread never gets here, because of the pe test. */
 #endif
   {
@@ -1968,7 +1968,7 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usc, int everReturn)
   Cmi_scanf_mutex = CmiCreateLock();
 
   skt_set_idle(obtain_idleFn);
-  if (!skt_ip_match(Cmi_charmrun_IP,skt_invalid_ip)) {
+  if (!skt_ip_match(Cmi_charmrun_IP,_skt_invalid_ip)) {
        set_signals();
 #if CMK_USE_TCP
        dataskt=skt_server(&dataport);
@@ -1995,7 +1995,7 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usc, int everReturn)
 #endif
 
   skt_set_idle(CmiYield);
-  Cmi_check_delay = 2.0+0.5*Cmi_numnodes;
+  Cmi_check_delay = 2.0+0.5*_Cmi_numnodes;
   if (Cmi_charmrun_fd==-1) /*Don't bother with check in standalone mode*/
        Cmi_check_delay=1.0e30;
 
index 2f1074627e147f6c86083098fc5be0b7404c10d3..e88bf8af576498e6dc7770b6237c2c2426d266cf 100644 (file)
@@ -35,7 +35,7 @@ static McQueue **MsgQueue;
 CpvDeclare(void*, CmiLocalQueue);
 
 int Cmi_argc;
-int Cmi_numpes;
+int _Cmi_numpes;
 int Cmi_usched;
 int Cmi_initret;
 CmiStartFn Cmi_startFn;
@@ -142,24 +142,24 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   USER_PARAMETERS *usrparam;
   pthread_t *aThread;
  
-  Cmi_numpes = 0; 
+  _Cmi_numpes = 0; 
   Cmi_usched = usched;
   Cmi_initret = initret;
   Cmi_startFn = fn;
 
-  CmiGetArgInt(argv,"+p",&Cmi_numpes);
-  if (Cmi_numpes <= 0)
+  CmiGetArgInt(argv,"+p",&_Cmi_numpes);
+  if (_Cmi_numpes <= 0)
   {
     CmiError("Error: requested number of processors is invalid %d\n",
-              Cmi_numpes);
+              _Cmi_numpes);
     abort();
   }
 
 
   pthread_mutex_init(&memory_mutex, (pthread_mutexattr_t *) 0);
 
-  MsgQueue=(McQueue **)CmiAlloc(Cmi_numpes*sizeof(McQueue *));
-  for(i=0; i<Cmi_numpes; i++) 
+  MsgQueue=(McQueue **)CmiAlloc(_Cmi_numpes*sizeof(McQueue *));
+  for(i=0; i<_Cmi_numpes; i++) 
     MsgQueue[i] = McQueueCreate();
 
   pthread_key_create(&perThreadKey, (void *) 0);
@@ -168,11 +168,11 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   pthread_mutex_init(&barrier_mutex, (pthread_mutexattr_t *) 0);
 
   /* suggest to IRIX that we actually use the right number of processors */
-  pthread_setconcurrency(Cmi_numpes);
+  pthread_setconcurrency(_Cmi_numpes);
 
   Cmi_argc = CmiGetArgc(argv);
-  aThread = (pthread_t *) CmiAlloc(sizeof(pthread_t) * Cmi_numpes);
-  for(i=1; i<Cmi_numpes; i++) {
+  aThread = (pthread_t *) CmiAlloc(sizeof(pthread_t) * _Cmi_numpes);
+  for(i=1; i<_Cmi_numpes; i++) {
     usrparam = (USER_PARAMETERS *) CmiAlloc(sizeof(USER_PARAMETERS));
     usrparam->argv = CmiCopyArgs(argv);
     usrparam->mype = i;
@@ -274,7 +274,7 @@ void CmiFreeSendFn(int destPE, int size, char *msg)
 void CmiSyncBroadcastFn(int size, char *msg)
 {
   int i;
-  for(i=0; i<Cmi_numpes; i++)
+  for(i=0; i<_Cmi_numpes; i++)
     if (CmiMyPe() != i) CmiSyncSendFn(i,size,msg);
 }
 
index 71790db990947f020f1e9f2213b064e6b7db3846..fb1bee53785bd2f9e94543d2894fc809a7ddd3f5 100644 (file)
@@ -1,4 +1,4 @@
-/*****************************************************************************
+/_*****************************************************************************
  * $Source$
  * $Author$
  * $Date$
@@ -41,9 +41,9 @@ int inside_comm = 0;
 #endif
 
 CpvDeclare(void*, CmiLocalQueue);
-int Cmi_mype;
-int Cmi_numpes;
-int Cmi_myrank;
+int _Cmi_mype;
+int _Cmi_numpes;
+int _Cmi_myrank;
 
 static int nthreads;
 static int requested_npe;
@@ -151,9 +151,9 @@ static void threadInit(void *arg)
 
 
   CpvInitialize(void*, CmiLocalQueue);
-  Cmi_mype  = usrparam->mype;
-  Cmi_myrank = 0;
-  Cmi_numpes =  usrparam->npe;
+  _Cmi_mype  = usrparam->mype;
+  _Cmi_myrank = 0;
+  _Cmi_numpes =  usrparam->npe;
 #ifdef DEBUG
   printf("thread %d/%d started \n", CmiMyPe(), CmiNumPes());
 #endif
@@ -162,7 +162,7 @@ static void threadInit(void *arg)
   CthInit(usrparam->argv);
   CpvAccess(CmiLocalQueue) = CdsFifo_Create();
   CmiTimerInit();
-  /*  neighbour_init(Cmi_mype); */
+  /*  neighbour_init(_Cmi_mype); */
   usadd(arena);
   ConverseCommonInit(usrparam->argv);
   if (usrparam->initret==0 || usrparam->mype) {
@@ -234,7 +234,7 @@ CmiCommHandle CmiAsyncSendFn(int destPE, int size, char *msg)
 
 void CmiFreeSendFn(int destPE, int size, char *msg)
 {
-  if (Cmi_mype==destPE) {
+  if (_Cmi_mype==destPE) {
     CQdCreate(CpvAccess(cQdState), 1);
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),msg);
   } else {
index ec30593c79c09ccadd8ad7c74cd2f71a1aca7731..8f28a46287c32b73ec88fc272d966d381b26fb99 100644 (file)
@@ -15,8 +15,8 @@
 #define ALL_NODES -1
 
 
-int  Cmi_mype;
-int  Cmi_numpes;
+int  _Cmi_mype;
+int  _Cmi_numpes;
 CpvDeclare(void*, CmiLocalQueue);
 
 
@@ -148,7 +148,7 @@ int size;
 char * msg;
 {
     char *temp;
-    if (Cmi_mype == destPE)
+    if (_Cmi_mype == destPE)
        {
           temp = (char *)CmiAlloc(size) ;
           memcpy(temp, msg, size) ;
@@ -179,7 +179,7 @@ void CmiFreeSendFn(destPE, size, msg)
      int destPE, size;
      char *msg;
 {
-    if (Cmi_mype == destPE)
+    if (_Cmi_mype == destPE)
        {
           CdsFifo_Enqueue(CpvAccess(CmiLocalQueue), msg);
        }
@@ -197,9 +197,9 @@ void CmiSyncBroadcastFn(size, msg)        /* ALL_EXCEPT_ME  */
 int size;
 char * msg;
 {
-    if (Cmi_numpes > 1) 
+    if (_Cmi_numpes > 1) 
        csend(MSG_TYPE, msg, size, ALL_NODES,PROCESS_PID);
-    CQdCreate(CpvAccess(cQdState), Cmi_numpes-1);
+    CQdCreate(CpvAccess(cQdState), _Cmi_numpes-1);
 }
 
 
@@ -209,7 +209,7 @@ char * msg;
 {
         long msgid;
         msgid = isend(MSG_TYPE, msg, size, ALL_NODES, PROCESS_PID);
-        CQdCreate(CpvAccess(cQdState), Cmi_numpes-1);
+        CQdCreate(CpvAccess(cQdState), _Cmi_numpes-1);
         return (CmiCommHandle) msgid;
 }
 
@@ -226,12 +226,12 @@ int size;
 char * msg;
 {
     char *temp;
-    if (Cmi_numpes > 1) 
+    if (_Cmi_numpes > 1) 
        csend(MSG_TYPE, msg, size, ALL_NODES,PROCESS_PID);
     temp = (char *)CmiAlloc(size) ;
     memcpy(temp, msg, size) ;
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue), temp); 
-    CQdCreate(CpvAccess(cQdState), Cmi_numpes);
+    CQdCreate(CpvAccess(cQdState), _Cmi_numpes);
 }
 
 
@@ -245,7 +245,7 @@ char * msg;
         temp = (char *)CmiAlloc(size) ;
         memcpy(temp, msg, size) ;
         CdsFifo_Enqueue(CpvAccess(CmiLocalQueue), temp);
-        CQdCreate(CpvAccess(cQdState), Cmi_numpes);
+        CQdCreate(CpvAccess(cQdState), _Cmi_numpes);
         return (CmiCommHandle) msgid;
 }
 
@@ -255,10 +255,10 @@ void CmiFreeBroadcastAllFn(size, msg)
 int size;
 char * msg;
 {
-    if (Cmi_numpes > 1)
+    if (_Cmi_numpes > 1)
        csend(MSG_TYPE, msg, size, ALL_NODES,PROCESS_PID);
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue), msg);
-    CQdCreate(CpvAccess(cQdState), Cmi_numpes);
+    CQdCreate(CpvAccess(cQdState), _Cmi_numpes);
 }
 
 
@@ -278,9 +278,9 @@ CmiStartFn fn;
 int usched, initret;
 {
   CpvInitialize(void*, CmiLocalQueue);
-  Cmi_mype = mynode();
-  Cmi_numpes = numnodes();
-  /*  neighbour_init(Cmi_mype); */
+  _Cmi_mype = mynode();
+  _Cmi_numpes = numnodes();
+  /*  neighbour_init(_Cmi_mype); */
   CpvAccess(CmiLocalQueue)= CdsFifo_Create();
   /*  CmiTimerInit(); */
   CthInit(argv);
index c143e93aa80960c55a5802d6c8e37bbb3f773eb5..ff04a6ce9f449d0473db75f303a3048b031d3e83 100644 (file)
@@ -38,9 +38,9 @@ enum {list_empty = -1 };
  * Local declarations for Cmi, used by common code
  */
 CpvDeclare(void*, CmiLocalQueue);
-int Cmi_mype;
-int Cmi_numpes;
-int Cmi_myrank;
+int _Cmi_mype;
+int _Cmi_numpes;
+int _Cmi_myrank;
 
 /*
  * Local queue functions, used by common code to store messages 
@@ -182,7 +182,7 @@ void CmiSyncSendFn(int dest_pe, int size, char *msg)
 
   McRetrieveRemote();
 
-  if (dest_pe == Cmi_mype)
+  if (dest_pe == _Cmi_mype)
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),dup_msg);
   else
   {
@@ -203,7 +203,7 @@ void CmiFreeSendFn(int dest_pe, int size, char *msg)
   McRetrieveRemote();
   ((McMsgHdr *)msg)->msg_type = Message;
 
-  if (dest_pe == Cmi_mype)
+  if (dest_pe == _Cmi_mype)
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),msg);
   else
   {
@@ -225,9 +225,9 @@ void CmiSyncBroadcastFn(int size, char *msg)
    */
   dup_msg = (McMsgHdr *)CmiAlloc(ALIGN8(size));
   memcpy(dup_msg,msg,size);
-  dup_msg->bcast.count = Cmi_numpes - 1;
+  dup_msg->bcast.count = _Cmi_numpes - 1;
   /*
-  CmiPrintf("PE %d broadcast handler=%d\n",Cmi_mype,dup_msg->handler);
+  CmiPrintf("PE %d broadcast handler=%d\n",_Cmi_mype,dup_msg->handler);
   */
   /*
    * Make the broadcast token point to the copied message
@@ -242,8 +242,8 @@ void CmiSyncBroadcastFn(int size, char *msg)
    * Enqueue copies of the token message on other nodes.  This code should
    * be similar to CmiSyncSend
    */
-  for(i=0; i<Cmi_numpes; i++)
-    if (i != Cmi_mype)
+  for(i=0; i<_Cmi_numpes; i++)
+    if (i != _Cmi_mype)
     {
       dup_tok = (McMsgHdr *)CmiAlloc(ALIGN8(hdr_size));
       memcpy(dup_tok,&bcast_msg_tok,hdr_size);
@@ -255,7 +255,7 @@ void CmiSyncBroadcastFn(int size, char *msg)
    * garbage collection.
    */
   McQueueAddToBack(broadcast_queue,dup_msg);
-  CQdCreate(CpvAccess(cQdState), Cmi_numpes-1);
+  CQdCreate(CpvAccess(cQdState), _Cmi_numpes-1);
 }
 
 CmiCommHandle CmiAsyncBroadcastFn(int size, char *msg)
@@ -274,7 +274,7 @@ void CmiSyncBroadcastAllFn(int size, char *msg)
 {
   int i;
   CmiSyncBroadcastFn(size,msg);
-  CmiSyncSendFn(Cmi_mype, size, msg);
+  CmiSyncSendFn(_Cmi_mype, size, msg);
 }
 
 CmiCommHandle CmiAsyncBroadcastAllFn(int size, char *msg)
@@ -310,8 +310,8 @@ void CmiSyncListSendFn(int npes, int *pes, int size, char *msg)
   n_remote_pes = 0;
   for (i=0; i < npes; i++)
   {
-    if (pes[i] == Cmi_mype)
-      CmiSyncSendFn(Cmi_mype, size, msg);
+    if (pes[i] == _Cmi_mype)
+      CmiSyncSendFn(_Cmi_mype, size, msg);
     else
       n_remote_pes++;
   }
@@ -338,7 +338,7 @@ void CmiSyncListSendFn(int npes, int *pes, int size, char *msg)
    * be similar to CmiSyncSend
    */
   for(i=0; i<npes; i++)
-    if (pes[i] != Cmi_mype)
+    if (pes[i] != _Cmi_mype)
     {
       dup_tok = (McMsgHdr *)CmiAlloc(ALIGN8(hdr_size));
       memcpy(dup_tok,&bcast_msg_tok,hdr_size);
@@ -501,7 +501,7 @@ void set_lock(long *lock, int pe)
 
 void clear_lock(long *lock, int pe)
 {
-//printf("[%d] clear lock on %d %ld. \n", Cmi_mype, pe, *lock);
+//printf("[%d] clear lock on %d %ld. \n", _Cmi_mype, pe, *lock);
   shmem_long_swap(lock, 0L, pe);
 //  shmem_long_p(lock, 0L, pe);
 //printf("clear lock end lock:%ld\n", *lock);
@@ -523,9 +523,9 @@ static void McInit(void)
 
   CpvInitialize(void *, CmiLocalQueue);
   CpvAccess(CmiLocalQueue) = CdsFifo_Create();
-  Cmi_mype = _my_pe();
-  Cmi_numpes = _num_pes();
-  Cmi_myrank = 0;
+  _Cmi_mype = _my_pe();
+  _Cmi_numpes = _num_pes();
+  _Cmi_myrank = 0;
 
   McInitList();
 }
@@ -545,22 +545,22 @@ static void McInitList(void)
   head.nxt_node = list_empty;
   head.nxt_addr = NULL;
   head.msg_sz = 0;
-  if (Cmi_numpes > MAX_PES)
+  if (_Cmi_numpes > MAX_PES)
   {
     CmiPrintf("Not enough processors allocated in machine.c.\n");
     CmiPrintf("Change MAX_PES in t3e/machine.c to at least %d and recompile Converse\n",
-    Cmi_numpes);
+    _Cmi_numpes);
   }
-  for(i=0; i < Cmi_numpes; i++)
+  for(i=0; i < _Cmi_numpes; i++)
   {
     head_lock[i] = 0;
     bcast_lock[i] = 0;
   }
-  my_lock = &(head_lock[Cmi_mype]);
+  my_lock = &(head_lock[_Cmi_mype]);
   shmem_barrier_all();
 /*
-  clear_lock(my_lock, Cmi_mype);
-  clear_lock(&bcast_lock[Cmi_mype], Cmi_mype);
+  clear_lock(my_lock, _Cmi_mype);
+  clear_lock(&bcast_lock[_Cmi_mype], _Cmi_mype);
 */
 }
 
@@ -580,7 +580,7 @@ static void McEnqueueRemote(void *msg, int msg_sz, int dst_pe)
   McDistList *msg_link;
 
   /*  CmiPrintf("PE %d outgoing msg = %d msg_type = %d size = %d dst_pe=%d\n",
-           Cmi_mype,msg,((McMsgHdr *)msg)->msg_type,msg_sz, dst_pe); */
+           _Cmi_mype,msg,((McMsgHdr *)msg)->msg_type,msg_sz, dst_pe); */
   /* 0. Free any delivered messages from the in_transit_queue list. */
   McCleanUpInTransit();
 
@@ -592,7 +592,7 @@ static void McEnqueueRemote(void *msg, int msg_sz, int dst_pe)
   ((McMsgHdr *)msg)->received_f = false;
 
   /* Set list fields to point back to this processor, this message.  */
-  tmp_link.nxt_node = Cmi_mype;
+  tmp_link.nxt_node = _Cmi_mype;
   tmp_link.nxt_addr = msg;
   tmp_link.msg_sz = msg_sz;
 
@@ -615,14 +615,14 @@ static void McEnqueueRemote(void *msg, int msg_sz, int dst_pe)
   shmem_quiet();
 
 #ifdef DEBUG
-  printf("[%d] Adding Message to pe %d\n",Cmi_mype,dst_pe);
-  printf("[%d]   nxt_node = %d\n",Cmi_mype,tmp_link.nxt_node);
-  printf("[%d]   nxt_addr = %x\n",Cmi_mype,tmp_link.nxt_addr);
-  printf("[%d]   msg_sz = %x\n",Cmi_mype,tmp_link.msg_sz);
-  printf("[%d] Old Message is now at %x\n",Cmi_mype,msg_link);
-  printf("[%d]   nxt_node = %d\n",Cmi_mype,msg_link->nxt_node);
-  printf("[%d]   nxt_addr = %x\n",Cmi_mype,msg_link->nxt_addr);
-  printf("[%d]   msg_sz = %x\n",Cmi_mype,msg_link->msg_sz);
+  printf("[%d] Adding Message to pe %d\n",_Cmi_mype,dst_pe);
+  printf("[%d]   nxt_node = %d\n",_Cmi_mype,tmp_link.nxt_node);
+  printf("[%d]   nxt_addr = %x\n",_Cmi_mype,tmp_link.nxt_addr);
+  printf("[%d]   msg_sz = %x\n",_Cmi_mype,tmp_link.msg_sz);
+  printf("[%d] Old Message is now at %x\n",_Cmi_mype,msg_link);
+  printf("[%d]   nxt_node = %d\n",_Cmi_mype,msg_link->nxt_node);
+  printf("[%d]   nxt_addr = %x\n",_Cmi_mype,msg_link->nxt_addr);
+  printf("[%d]   msg_sz = %x\n",_Cmi_mype,msg_link->msg_sz);
 #endif
 
   /* 5. Release lock */
@@ -654,14 +654,14 @@ static void McRetrieveRemote(void)
     return;
 
   /* 0) Lock list pointer. */
-  set_lock(my_lock, Cmi_mype);
+  set_lock(my_lock, _Cmi_mype);
 
   /* 1) Replace list pointer with NULL and unlock list */
   list_head = head;
   head.nxt_node = list_empty;
   head.nxt_addr = NULL;
   head.msg_sz = 0;
-  clear_lock(my_lock, Cmi_mype);
+  clear_lock(my_lock, _Cmi_mype);
 
   /* 2) Get each message into local memory
    * Start copying the messages into local memory, putting messages into
@@ -683,7 +683,7 @@ static void McRetrieveRemote(void)
               ALIGN8(cur_node->msg_sz)/8, cur_node->nxt_node);
 
     /*    CmiPrintf("PE %d incoming msg = %d msg_type = %d, size = %d\n",
-             Cmi_mype,cur_msg,cur_msg->msg_type,cur_node->msg_sz);*/
+             _Cmi_mype,cur_msg,cur_msg->msg_type,cur_node->msg_sz);*/
 
     /* If it is a broadcast message, retrieve the actual message */
     if (cur_msg->msg_type == BcastMessage)
@@ -696,7 +696,7 @@ static void McRetrieveRemote(void)
       /*
       CmiPrintf(
        "PE %d getting message from node %d at addr %d to %d, size=%d\n",
-       Cmi_mype,cur_node->nxt_node,cur_msg->bcast.ptr,bcast_ptr,
+       _Cmi_mype,cur_node->nxt_node,cur_msg->bcast.ptr,bcast_ptr,
        cur_msg->bcast_msg_size
        );
        */
@@ -707,7 +707,7 @@ static void McRetrieveRemote(void)
       /*
       CmiPrintf(
       "PE %d received broadcast message count=%d size=%d handler=%d\n",
-      Cmi_mype,bcast_ptr->bcast.count,
+      _Cmi_mype,bcast_ptr->bcast.count,
       cur_msg->bcast_msg_size,bcast_ptr->handler
       );
       */
@@ -764,7 +764,7 @@ static void McCleanUpInTransit(void)
     if (msg->bcast.count == 0)
     {
       /* 
-        CmiPrintf("PE %d freeing broadcast message at %d\n",Cmi_mype,msg);
+        CmiPrintf("PE %d freeing broadcast message at %d\n",_Cmi_mype,msg);
        */
       CmiFree(msg);
     }
@@ -806,7 +806,7 @@ static void McCleanUpInTransit(void)
   in_transit_queue = swap_ptr;
 #ifdef DEBUG
   CmiPrintf("[%d] done in_transit_queue = %d, tmp_queue = %d\n",
-       Cmi_mype,in_transit_queue->len,in_transit_tmp_queue->len);
+       _Cmi_mype,in_transit_queue->len,in_transit_tmp_queue->len);
 #endif
 }
 
@@ -868,7 +868,7 @@ static void McQueueAddToBack(McQueue *queue, void *element)
     queue->first = 0;
   }
 #ifdef DEBUG
-  CmiPrintf("[%d] Adding %x\n",Cmi_mype,element);
+  CmiPrintf("[%d] Adding %x\n",_Cmi_mype,element);
 #endif
   queue->blk[(queue->first+queue->len++)%queue->blk_len] = element;
   inside_comm = 0;
index 4cf9bf89b271db8419219b40e92d146f2fe57016..1a328e6a2b84754123eb0b19dfe6fc21470b9ae1 100644 (file)
@@ -23,8 +23,8 @@
 
 static void **McQueue;
 
-int Cmi_mype;
-int Cmi_numpes;
+int _Cmi_mype;
+int _Cmi_numpes;
 
 
 CsvDeclare(int, CsdStopCount);
@@ -67,7 +67,7 @@ int handler;
 CmiUniContextSwitch(i)
 int i;
 {
-  Cmi_mype = i; 
+  _Cmi_mype = i; 
 }
 
 void CmiNotifyIdle()
@@ -107,7 +107,7 @@ char * msg;
 
     buf =  (char *) CmiAlloc(size);
     memcpy(buf,msg,size);
-    sim_send_message(Cmi_mype,buf,size,FALSE,destPE);
+    sim_send_message(_Cmi_mype,buf,size,FALSE,destPE);
 }
 
 
@@ -129,7 +129,7 @@ int destPE;
 int size;
 char * msg;
 {
-     sim_send_message(Cmi_mype,msg,size,FALSE,destPE);
+     sim_send_message(_Cmi_mype,msg,size,FALSE,destPE);
 }
 
 
@@ -170,8 +170,8 @@ int size;
 char * msg;
 {
     int i;
-    for(i=0; i<Cmi_numpes; i++)
-       if (i!= Cmi_mype) CmiSyncSendFn(i,size,msg);
+    for(i=0; i<_Cmi_numpes; i++)
+       if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
          
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),msg);
 }
@@ -182,8 +182,8 @@ int size;
 char * msg;
 {
     int i;
-    for(i=0; i<Cmi_numpes; i++)
-       if (i!= Cmi_mype) CmiSyncSendFn(i,size,msg);
+    for(i=0; i<_Cmi_numpes; i++)
+       if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
 }
 
 
@@ -195,8 +195,8 @@ char * msg;
 
      char *buf;
 
-     for(i=0; i<Cmi_numpes; i++)
-        if (i!= Cmi_mype) CmiSyncSendFn(i,size,msg);
+     for(i=0; i<_Cmi_numpes; i++)
+        if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
 
      buf =  (char *) CmiAlloc(size);
      memcpy(buf,msg,size);
@@ -262,8 +262,8 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usc, int initret)
     exit(1);
   }
 
-  Cmi_numpes = requested_npe;
-  Cmi_mype   = 0;
+  _Cmi_numpes = requested_npe;
+  _Cmi_mype   = 0;
 
   McQueue = (void **) malloc(requested_npe * sizeof(void *)); 
   for(i=0; i<requested_npe; i++) McQueue[i] = CdsFifo_Create();
index 928771d0a82b89bf35797c6aaa7b2cf489f3e62f..f058c6bed643d3af4835846dbb213ab49da9a134 100644 (file)
@@ -151,7 +151,7 @@ static void simulate()
     int pno;
     
     while ( (pno = select_processor())  )  {
-        Cmi_mype = pno-1;
+        _Cmi_mype = pno-1;
         if (IS_CPU(pno)) {
 
             if (  CpvAccess(CsdStopFlag) == 0)
index 4a5094a757fa15618b9a1e46f213463c3b1496a5..86d1c16f5ff11bcb9bfb0ed4cb4dbb6fd557ec73 100644 (file)
@@ -13,9 +13,9 @@
 
 #define FLIPBIT(node,bitnumber) (node ^ (1 << bitnumber))
 
-int Cmi_mype;
-int Cmi_numpes;
-int Cmi_myrank;
+int _Cmi_mype;
+int _Cmi_numpes;
+int _Cmi_myrank;
 CpvDeclare(void*, CmiLocalQueue);
 
 #define BLK_LEN  512
@@ -173,7 +173,7 @@ void CmiSyncSendFn(int destPE, int size, char *msg)
 {
   char *dupmsg = (char *) CmiAlloc(size);
   memcpy(dupmsg, msg, size);
-  if (Cmi_mype==destPE) {
+  if (_Cmi_mype==destPE) {
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),dupmsg);
     CQdCreate(CpvAccess(cQdState), 1);
   }
@@ -203,7 +203,7 @@ CmiCommHandle CmiAsyncSendFn(int destPE, int size, char *msg)
 
 void CmiFreeSendFn(int destPE, int size, char *msg)
 {
-  if (Cmi_mype==destPE) {
+  if (_Cmi_mype==destPE) {
     CQdCreate(CpvAccess(cQdState), 1);
     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),msg);
   } else {
@@ -218,9 +218,9 @@ void CmiSyncBroadcastFn(int size, char *msg)     /* ALL_EXCEPT_ME  */
 {
   int i ;
      
-  for ( i=Cmi_mype+1; i<Cmi_numpes; i++ ) 
+  for ( i=_Cmi_mype+1; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
-  for ( i=0; i<Cmi_mype; i++ ) 
+  for ( i=0; i<_Cmi_mype; i++ ) 
     CmiSyncSendFn(i, size,msg) ;
 }
 
@@ -229,9 +229,9 @@ CmiCommHandle CmiAsyncBroadcastFn(int size, char *msg)
 {
   int i ;
 
-  for ( i=Cmi_mype+1; i<Cmi_numpes; i++ ) 
+  for ( i=_Cmi_mype+1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
-  for ( i=0; i<Cmi_mype; i++ ) 
+  for ( i=0; i<_Cmi_mype; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
   return (CmiCommHandle) (CmiAllAsyncMsgsSent());
 }
@@ -246,7 +246,7 @@ void CmiSyncBroadcastAllFn(int size, char *msg)        /* All including me */
 {
   int i ;
      
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
 }
 
@@ -254,7 +254,7 @@ CmiCommHandle CmiAsyncBroadcastAllFn(int size, char *msg)
 {
   int i ;
 
-  for ( i=1; i<Cmi_numpes; i++ ) 
+  for ( i=1; i<_Cmi_numpes; i++ ) 
     CmiAsyncSendFn(i,size,msg) ;
   return (CmiCommHandle) (CmiAllAsyncMsgsSent());
 }
@@ -263,7 +263,7 @@ void CmiFreeBroadcastAllFn(int size, char *msg)  /* All including me */
 {
   int i ;
      
-  for ( i=0; i<Cmi_numpes; i++ ) 
+  for ( i=0; i<_Cmi_numpes; i++ ) 
     CmiSyncSendFn(i,size,msg) ;
   CmiFree(msg) ;
 }
@@ -284,8 +284,8 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   int n ;
   int nbuf[4];
   
-  Cmi_myrank = 0;
-  mpc_environ(&Cmi_numpes, &Cmi_mype);
+  _Cmi_myrank = 0;
+  mpc_environ(&_Cmi_numpes, &_Cmi_mype);
   mpc_task_query(nbuf, 4, 3);
   dontcare = nbuf[0];
   allmsg = nbuf[1];
@@ -293,7 +293,7 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
   msgtype = nbuf[0];
   
   /* find dim = log2(numpes), to pretend we are a hypercube */
-  for ( Cmi_dim=0,n=Cmi_numpes; n>1; n/=2 )
+  for ( Cmi_dim=0,n=_Cmi_numpes; n>1; n/=2 )
     Cmi_dim++ ;
   /* CmiSpanTreeInit(); */
   CmiTimerInit();