Merge branch 'charm' of charmgit:charm into harshitha/adaptive_lb harshitha/adaptive_lb
authorHarshitha <gplkrsh2@illinois.edu>
Wed, 24 Oct 2012 06:55:23 +0000 (01:55 -0500)
committerHarshitha <gplkrsh2@illinois.edu>
Wed, 24 Oct 2012 06:55:23 +0000 (01:55 -0500)
20 files changed:
doc/charm++/sdag.tex
doc/charm++/startuporder.tex
src/arch/mpi/machine-ctrlmsg.c
src/arch/mpi/machine.c
src/ck-core/sdag.h
src/conv-core/convcore.c
src/conv-core/converse.h
src/libs/ck-libs/ampi/ampif.C
src/libs/ck-libs/cache/CkCache.C
src/libs/ck-libs/cache/CkCache.ci
src/libs/ck-libs/cache/CkCache.h
src/libs/ck-libs/cache/Makefile
src/xlat-i/sdag/CEntry.C
src/xlat-i/sdag/CSdagConstruct.C
src/xlat-i/sdag/CStateVar.h
src/xlat-i/xi-grammar.tab.C
src/xlat-i/xi-grammar.y
src/xlat-i/xi-symbol.C
src/xlat-i/xi-symbol.h
tests/ampi/stacksize/test.c

index d369c2092e0d5dd39cf8467a169a3d0c9084b155..3cb747cea820e56c1d15b0198691ec48cdc74440 100644 (file)
@@ -104,7 +104,7 @@ chare ComputeObject \{
 
 // in C++ file
 class ComputeObject : public CBase\_ComputeObject \{
-  ComputeObject\_SDAG\_Code
+  ComputeObject\_SDAG\_CODE
   int   expectedMessageCount;
   Input first, second;
 
@@ -179,7 +179,7 @@ chare ComputeObject \{
 
 // in C++ file
 class ComputeObject : public CBase_ComputeObject \{
-  ComputeObject_SDAG_Code
+  ComputeObject_SDAG_CODE
 
 public:
   ComputeObject() \{
@@ -271,7 +271,7 @@ chare ComputeObject \{
 
 // in C++ file
 class ComputeObject : public CBase_ComputeObject \{
-  ComputeObject_SDAG_Code
+  ComputeObject_SDAG_CODE
 
 public:
   ComputeObject() \{
@@ -309,7 +309,7 @@ chare ComputeObject \{
 
 // in C++ file
 class ComputeObject : public CBase_ComputeObject \{
-  ComputeObject_SDAG_Code
+  ComputeObject_SDAG_CODE
   int n, iter;
 
 public:
@@ -374,7 +374,7 @@ chare ComputeObject \{
 
 // in C++ file
 class ComputeObject : public CBase_ComputeObject \{
-  ComputeObject_SDAG_Code
+  ComputeObject_SDAG_CODE
 
 public:
   ComputeObject() \{
index 933cceb9514f483e70656b29134246975c012635..7d79adbce443a246e185ee06a71099d8b018e3bd 100644 (file)
@@ -32,7 +32,7 @@ on other Group or NodeGroup objects on a PE. However, if your program structure
 it, you can explicitly specify that the creation of certain Groups/NodeGroups depends
 on the creation of others, as described in \S~\ref{sec:groups/creation}.
 In addition, since those objects are initialized
-after the initialization of readonly variabales, readonly variables can be used
+after the initialization of readonly variables, readonly variables can be used
 in the constructors of Groups and NodeGroups.
 
 \item \charmpp{} Array Creation: the order in which array constructors are called on PEs is
index 8da4dfdf9f01ccb2cadfabf6877c48d9c7e7dd2d..131ef2305b25004136431f06caac5ca26c71ecec 100644 (file)
 #if USE_MPI_CTRLMSG_SCHEME
 
 #define CTRL_MSG_TAG         (TAG-13)
+#define USE_NUM_TAGS            1000
 
-static int MPI_CTRL_MSG_CNT=10;
+static int MPI_CTRL_MSG_CNT=100;
+static int tags;
 
 typedef struct MPICtrlMsgEntry{
        int src;
        int size;
+        int tag;
 }MPICtrlMsgEntry;
 
 typedef struct RecvCtrlMsgEntry{
@@ -43,6 +46,8 @@ static void createCtrlMsgIrecvBufs(){
        MPICtrlMsgEntry *bufPtr = NULL;
        MPI_Request *reqPtr = NULL;
        int count = MPI_CTRL_MSG_CNT;
+
+        tags = 0;
        
        recvCtrlMsgList.bufCnt = count;
        recvCtrlMsgList.ctrlReqs = (MPI_Request *)malloc(sizeof(MPI_Request)*count);
@@ -53,7 +58,7 @@ static void createCtrlMsgIrecvBufs(){
        
        for(i=0; i<count; i++, bufPtr++, reqPtr++){
                if(MPI_SUCCESS != MPI_Irecv(bufPtr, sizeof(MPICtrlMsgEntry), 
-                                                                                                        MPI_BYTE, MPI_ANY_SOURCE, CTRL_MSG_TAG, charmComm, reqPtr)){
+                              MPI_BYTE, MPI_ANY_SOURCE, CTRL_MSG_TAG, charmComm, reqPtr)){
                        CmiAbort("MPI_Irecv failed in creating pre-posted ctrl msg buffers\n");
                }
        }
@@ -64,14 +69,15 @@ static void sendViaCtrlMsg(int node, int size, char *msg, SMSG_LIST *smsg){
 
        one.src = CmiMyNode();
        one.size = size;
+        one.tag = TAG + 100 + tags;
+
+        tags = (tags+1)%USE_NUM_TAGS;
        
        START_TRACE_SENDCOMM(msg);
-       if(MPI_SUCCESS != MPI_Send((void *)&one, sizeof(MPICtrlMsgEntry), MPI_BYTE, node, 
-                                                                                                  CTRL_MSG_TAG, charmComm)){
+       if(MPI_SUCCESS != MPI_Send((void *)&one, sizeof(MPICtrlMsgEntry), MPI_BYTE, node, CTRL_MSG_TAG, charmComm)){
                CmiAbort("MPI_Send failed in sending ctrl msg\n");
        }
-       
-       if (MPI_SUCCESS != MPI_Isend((void *)msg,size,MPI_BYTE,node,TAG,charmComm,&(smsg->req)))
+       if (MPI_SUCCESS != MPI_Isend((void *)msg,size,MPI_BYTE,node,one.tag,charmComm,&(smsg->req)))
             CmiAbort("MPISendOneMsg: MPI_Isend failed!\n");
        END_TRACE_SENDCOMM(msg);
 }
@@ -86,7 +92,6 @@ static int recvViaCtrlMsg(){
        int flg = 0;
        int nbytes = -1;
        MPI_Status sts;
-       
        if(MPI_SUCCESS != MPI_Testany(count, ctrlReqs, &completed_index, &flg, &sts)){
                CmiAbort("MPI_Testany failed for checking if ctrl msg is received\n");
        }
@@ -106,7 +111,7 @@ static int recvViaCtrlMsg(){
                }
                
                /* irecv the actual msg */
-               if(MPI_SUCCESS != MPI_Irecv(actualMsg, msgsize, MPI_BYTE, src, TAG, charmComm, &(one->req))){
+               if(MPI_SUCCESS != MPI_Irecv(actualMsg, msgsize, MPI_BYTE, src, ctrlMsgs[completed_index].tag, charmComm, &(one->req))){
                        CmiAbort("MPI_Irecv failed after a ctrl msg is received\n");
                }
                one->msg = actualMsg;
@@ -119,4 +124,4 @@ static int recvViaCtrlMsg(){
        return nbytes;
 }
 
-#endif
\ No newline at end of file
+#endif
index 58591905237aea9b818df0798ac949a9ff159b29..5c9a82156f2c660f1b5367528df69499675cc72e 100644 (file)
@@ -442,7 +442,7 @@ static CmiCommHandle MPISendOneMsg(SMSG_LIST *smsg) {
         END_TRACE_SENDCOMM(msg);
     }
 #elif USE_MPI_CTRLMSG_SCHEME
-       sendViaCtrlMsg(node, size, msg, smsg);
+    sendViaCtrlMsg(node, size, msg, smsg);
 #else
 /* branch not using MPI_POST_RECV or USE_MPI_CTRLMSG_SCHEME */
 
@@ -461,8 +461,9 @@ static CmiCommHandle MPISendOneMsg(SMSG_LIST *smsg) {
     CpvAccess(MsgQueueLen)++;
     if (CpvAccess(sent_msgs)==0)
         CpvAccess(sent_msgs) = smsg;
-    else
+    else {
         CpvAccess(end_sent)->next = smsg;
+    }
     CpvAccess(end_sent) = smsg;
 
 #if !CMI_DYNAMIC_EXERT_CAP && !CMI_EXERT_SEND_CAP
@@ -624,6 +625,7 @@ static int PumpMsgs(void) {
 #if USE_MPI_CTRLMSG_SCHEME
        doSyncRecv = 0;
        nbytes = recvViaCtrlMsg();
+  recd = 1;
        if(nbytes == -1) break;
 #elif MPI_POST_RECV
                /* First check posted recvs then do  probe unmatched outstanding messages */
@@ -841,7 +843,6 @@ static int PumpMsgs(void) {
     MPI_Status sts;
     while(waitIrecvListHead->next) {
         IRecvList irecvEnt = waitIrecvListHead->next;
-
         START_EVENT();
                 
         /*printf("PE[%d]: check irecv entry=%p\n", CmiMyPe(), irecvEnt);*/
@@ -855,7 +856,7 @@ static int PumpMsgs(void) {
         handleOneRecvedMsg(irecvEnt->size, irecvEnt->msg);
         waitIrecvListHead->next = irecvEnt->next;
         irecvListEntryFree(irecvEnt);
-        recd = 1;        
+        //recd = 1;        
     }
     if(waitIrecvListHead->next == NULL)
         waitIrecvListTail = waitIrecvListHead;
@@ -1873,7 +1874,6 @@ int CmiBarrierZero() {
         if (CmiMyNode() == 0)  {
             for (i=0; i<CmiNumNodes()-1; i++) {
                 START_EVENT();
-
                 if (MPI_SUCCESS != MPI_Recv(msg,1,MPI_BYTE,MPI_ANY_SOURCE,BARRIER_ZERO_TAG, charmComm,&sts))
                     CmiPrintf("MPI_Recv failed!\n");
 
index cf6b75f077461a2a4db6a7ec586d2ad2cd005048..9759fd4471a984663346304ebcaf96712c05ce04 100644 (file)
@@ -124,16 +124,16 @@ class TListCWhenTrigger
       return first;
     }
 
-    CWhenTrigger* remove(CWhenTrigger *data)
+    void remove(CWhenTrigger *data)
     {
       // case 1: empty list
       if (first == 0)
-        return 0;
+        return;
       // case 2: first element to be removed
       if(first == data) {
         first = first->next;
        if(first==0) last=0;
-        return first;
+        return;
       }
       // case 3: middle or last element to be removed
       CWhenTrigger *nn;
@@ -143,7 +143,7 @@ class TListCWhenTrigger
           prev->next = nn->next;
          if(nn==last)
            last=prev;
-          return prev;
+          return;
         }
         prev = nn;
       }
@@ -369,8 +369,8 @@ class CDep {
 
    // deregister trigger from all
    // the entries it is registered for
-   CWhenTrigger* deRegister(CWhenTrigger *trigger) {
-     return whens[trigger->whenID]->remove(trigger);
+   void deRegister(CWhenTrigger *trigger) {
+     whens[trigger->whenID]->remove(trigger);
    }
 
    // buffer a message for a specific entry point with a specified
@@ -460,10 +460,15 @@ class CDep {
    void removeAllSpeculationIndex(int speculationIndex) {
      for (int i = 0; i < numWhens; i++) {
        TListCWhenTrigger *wlist = whens[i];
-       for (CWhenTrigger *elem = wlist->begin(); !wlist->end(); elem = wlist->next()) {
-         if (elem == 0) break;
+       CWhenTrigger *elem = wlist->begin();
+       while (elem && !wlist->end()) {
          if (elem->speculationIndex == speculationIndex) {
-           elem = deRegister(elem);
+           CWhenTrigger *cancelled = elem;
+           deRegister(elem);
+           elem = wlist->next();
+           delete cancelled;
+         } else {
+           elem = wlist->next();
          }
        }
      }
index 3eec22ca9b14cef341fb1f918a8a768fa7e43c13..cee4024cbfd166aac3bc65cb44b859641a5410ec 100644 (file)
@@ -1248,10 +1248,11 @@ void CmiTimerInit(char **argv)
   /*fprintf(stderr, "Blue Gene/Q running at clock speed of %d Mhz\n", clockMhz);*/
 
   /* try to synchronize calling barrier */
+#if !CMK_MEM_CHECKPOINT && !_FAULT_MLOG_ && !_FAULT_CAUSAL_
   CmiBarrier();
   CmiBarrier();
   CmiBarrier();
-
+#endif
   CpvAccess(inittime) = GetTimeBase (); 
 }
 
index a3400415a637f37db1eec045f7cae9dc922b189c..c4d14ef3e42237ad7e401485ab2a5a1e644283ee 100644 (file)
@@ -528,9 +528,17 @@ typedef CMK_TYPEDEF_INT8      CmiInt8;
 typedef CMK_TYPEDEF_UINT2     CmiUInt2;
 typedef CMK_TYPEDEF_UINT4     CmiUInt4;
 typedef CMK_TYPEDEF_UINT8     CmiUInt8;
+#if CMK___int128_DEFINED
+typedef __int128              CmiInt16;
+typedef unsigned __int128     CmiUInt16;
+#define CMK_HAS_INT16         1
+#else
+#define CMK_HAS_INT16         0
+#endif
 typedef CMK_TYPEDEF_FLOAT4    CmiFloat4;
 typedef CMK_TYPEDEF_FLOAT8    CmiFloat8;
 
+
 #if CMK_SIZET_64BIT
 typedef CmiUInt8     CmiIntPtr;
 #else
index fe1734b174c3d5a87f6ccfaf4d0f203a5b209b46..05282f48474d2ba739506f8d674de5b7aec683b6 100644 (file)
@@ -148,6 +148,9 @@ FDECL {
 #define mpi_checkpoint FTN_NAME( MPI_CHECKPOINT , mpi_checkpoint )
 #define mpi_memcheckpoint FTN_NAME( MPI_MEMCHECKPOINT , mpi_memcheckpoint )
 
+#define mpi_get_argc FTN_NAME( MPI_GET_ARGC , mpi_get_argc )
+#define mpi_get_argv FTN_NAME( MPI_GET_ARGV , mpi_get_argv )
+
 /* MPI-2 */
 #define mpi_type_get_envelope FTN_NAME ( MPI_TYPE_GET_ENVELOPE , mpi_type_get_envelope )
 #define mpi_type_get_contents FTN_NAME ( MPI_TYPE_GET_CONTENTS , mpi_type_get_contents )
@@ -899,6 +902,27 @@ void mpi_memcheckpoint(){
   AMPI_MemCheckpoint();
 }
 
+void mpi_get_argc(int *c, int *ierr)
+{
+  *c = CkGetArgc();
+  *ierr = 0;
+}
+
+void mpi_get_argv(int *c, char *str, int *ierr, int len)
+{
+  char ** argv = CkGetArgv();
+  int nc = CkGetArgc();
+  if (*c < nc) {
+    strncpy(str, argv[*c], strlen(argv[*c]));
+    for (int j=strlen(argv[*c]); j<len; j++)  str[j] = ' ';
+    *ierr = 0;
+  }
+  else {
+    memset(str, ' ', len);
+    *ierr = 1;
+  }
+}
+
 void mpi_comm_remote_size(int *comm, int *size, int *ierr){
   *ierr = AMPI_Comm_remote_size(*comm, size);
 }
index 54c2f7dd37c36df93aa3d26edcfe3da930cf6c89..df8f39e968d2f8cc0111333322845a681f5b0d8c 100644 (file)
@@ -1,306 +1,5 @@
 #include "CkCache.h"
 
-  CkCacheManager::CkCacheManager(int size, CkGroupID gid) {
-    init();
-    numLocMgr = 1;
-    numLocMgrWB = 0;
-    locMgr = new CkGroupID[1];
-    locMgr[0] = gid;
-    maxSize = (CmiUInt8)size * 1024 * 1024;
-  }
-
-  CkCacheManager::CkCacheManager(int size, int n, CkGroupID *gid) {
-    init();
-    numLocMgr = n;
-    numLocMgrWB = 0;
-    locMgr = new CkGroupID[n];
-    for (int i=0; i<n; ++i) locMgr[i] = gid[i];
-    maxSize = (CmiUInt8)size * 1024 * 1024;
-  }
-
-  CkCacheManager::CkCacheManager(int size, int n, CkGroupID *gid, int nWB, CkGroupID *gidWB) {
-    init();
-    numLocMgr = n;
-    locMgr = new CkGroupID[n];
-    for (int i=0; i<n; ++i) locMgr[i] = gid[i];
-    numLocMgrWB = nWB;
-    locMgrWB = new CkGroupID[nWB];
-    for (int i=0; i<n; ++i) locMgrWB[i] = gidWB[i];
-    maxSize = (CmiUInt8)size * 1024 * 1024;
-  }
-
-  CkCacheManager::CkCacheManager(CkMigrateMessage* m) : CBase_CkCacheManager(m) {
-    init();
-  }
-
-  void CkCacheManager::init() {
-    numChunks = 0;
-    numLocMgr = 0;
-    locMgr = NULL;
-    maxSize = 0;
-    syncdChares = 0;
-    cacheTable = NULL;
-    chunkAck = NULL;
-    chunkWeight = NULL;
-    storedData = 0;
-#if COSMO_STATS > 0
-    dataArrived = 0;
-    dataTotalArrived = 0;
-    dataMisses = 0;
-    dataLocal = 0;
-    totalDataRequested = 0;
-#endif
-  }
-
-  void CkCacheManager::pup(PUP::er &p) {
-    CBase_CkCacheManager::pup(p);
-    p | numLocMgr;
-    if (p.isUnpacking()) locMgr = new CkGroupID[numLocMgr];
-    PUParray(p,locMgr,numLocMgr);
-    p | numLocMgrWB;
-    if (p.isUnpacking()) locMgrWB = new CkGroupID[numLocMgrWB];
-    PUParray(p,locMgrWB,numLocMgrWB);
-    p | maxSize;
-  }
-
-  void * CkCacheManager::requestData(CkCacheKey what, CkArrayIndex &_toWhom, int chunk, CkCacheEntryType *type, CkCacheRequestorData &req){
-
-    std::map<CkCacheKey,CkCacheEntry *>::iterator p;
-    CkArrayIndex toWhom(_toWhom);
-    CkAssert(chunkAck[chunk] > 0);
-    p = cacheTable[chunk].find(what);
-    CkCacheEntry *e;
-#if COSMO_STATS > 0
-    totalDataRequested++;
-#endif
-    if (p != cacheTable[chunk].end()) {
-      e = p->second;
-      CkAssert(e->home == toWhom);
-      //CkAssert(e->begin == begin);
-      //CkAssert(e->end == end);
-#if COSMO_STATS > 1
-      e->totalRequests++;
-#endif
-      if (e->data != NULL) {
-        return e->data;
-      }
-      if (!e->requestSent) {// || _nocache) {
-        e->requestSent = true;
-        if ((e->data = type->request(toWhom, what)) != NULL) {
-          e->replyRecvd = true;
-          return e->data;
-        }
-      }
-    } else {
-      e = new CkCacheEntry(what, toWhom, type);
-#if COSMO_STATS > 1
-      e->totalRequests++;
-#endif
-      cacheTable[chunk][what] = e;
-      e->requestSent = true;
-      if ((e->data = type->request(toWhom, what)) != NULL) {
-        e->replyRecvd = true;
-        return e->data;
-      }
-    }
-
-    e->requestorVec.push_back(req);
-    outStandingRequests[what] = chunk;
-#if COSMO_STATS > 1
-    e->misses++;
-#endif
-    return NULL;
-  }
-
-  void * CkCacheManager::requestDataNoFetch(CkCacheKey key, int chunk) {
-    std::map<CkCacheKey,CkCacheEntry *>::iterator p = cacheTable[chunk].find(key);
-    if (p != cacheTable[chunk].end()) {
-      return p->second->data;
-    }
-    return NULL;
-  }
-  
-  CkCacheEntry * CkCacheManager::requestCacheEntryNoFetch(CkCacheKey key, int chunk) {
-    std::map<CkCacheKey,CkCacheEntry *>::iterator p = cacheTable[chunk].find(key);
-    if (p != cacheTable[chunk].end()) {
-      return p->second;
-    }
-    return NULL;
-  }
-  
-  std::map<CkCacheKey,CkCacheEntry*> *CkCacheManager::getCache(){
-    return cacheTable;
-  }
-
-  void CkCacheManager::recvData(CkCacheFillMsg *msg) {
-    CkCacheKey key = msg->key;
-    std::map<CkCacheKey,int>::iterator pchunk = outStandingRequests.find(key);
-    CkAssert(pchunk != outStandingRequests.end());
-    int chunk = pchunk->second;
-    CkAssert(chunk >= 0 && chunk < numChunks);
-    CkAssert(chunkAck[chunk] > 0);
-    outStandingRequests.erase(pchunk);
-    
-    std::map<CkCacheKey,CkCacheEntry*>::iterator p;
-    p = cacheTable[chunk].find(key);
-    CkAssert(p != cacheTable[chunk].end());
-    CkCacheEntry *e = p->second;
-    e->data = e->type->unpack(msg, chunk, e->home);
-    storedData += e->type->size(e->data);
-    
-    std::vector<CkCacheRequestorData>::iterator caller;
-    for (caller = e->requestorVec.begin(); caller != e->requestorVec.end(); caller++) {
-      caller->deliver(key, e->data, chunk);
-    }
-    e->requestorVec.clear();
-  }
-  
-  void CkCacheManager::recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType *type, int chunk, void *data) {
-    std::map<CkCacheKey,CkCacheEntry*>::iterator p = cacheTable[chunk].find(key);
-    CkCacheEntry *e;
-    if (p == cacheTable[chunk].end()) {
-      e = new CkCacheEntry(key, from, type);
-      cacheTable[chunk][key] = e;
-    } else {
-      e = p->second;
-      storedData -= e->type->size(e->data);
-      e->type->writeback(e->home, e->key, e->data);
-    }
-    e->replyRecvd = true;
-    e->data = data;
-    storedData += e->type->size(data);
-    
-    std::vector<CkCacheRequestorData>::iterator caller;
-    for (caller = e->requestorVec.begin(); caller != e->requestorVec.end(); caller++) {
-      caller->deliver(key, e->data, chunk);
-    }
-    e->requestorVec.clear();
-  }
-
-  void CkCacheManager::cacheSync(int &_numChunks, CkArrayIndex &chareIdx, int &localIdx) {
-    finishedChunks = 0;
-    if (syncdChares > 0) {
-      _numChunks = numChunks;
-      //CkPrintf("Cache %d: sync following\n",thisgroup.idx);
-    } else {
-      syncdChares = 1;
-      //CkPrintf("Cache %d: sync\n",thisgroup.idx);
-
-      localChares.reset();
-      localCharesWB.reset();
-      for (int i=0; i<numLocMgr; ++i) {
-        CkLocMgr *mgr = (CkLocMgr *)CkLocalBranch(locMgr[i]);
-        mgr->iterate(localChares);
-      }
-      for (int i=0; i<numLocMgrWB; ++i) {
-        CkLocMgr *mgr = (CkLocMgr *)CkLocalBranch(locMgrWB[i]);
-        mgr->iterate(localChares);
-        mgr->iterate(localCharesWB);
-      }
-
-#if COSMO_STATS > 0
-      dataArrived = 0;
-      dataTotalArrived = 0;
-      dataMisses = 0;
-      dataLocal = 0;
-      totalDataRequested = 0;
-      maxData = 0;
-#endif
-
-      for (int chunk=0; chunk<numChunks; ++chunk) {
-        CkAssert(cacheTable[chunk].empty());
-        CkAssert(chunkAck[chunk]==0);
-        CkAssert(chunkAckWB[chunk]==0);
-      }
-      CkAssert(outStandingRequests.empty());
-      storedData = 0;
-
-      if (numChunks != _numChunks) {
-        if(numChunks != 0) {
-          delete []cacheTable;
-          delete []chunkAck;
-          delete []chunkAckWB;
-          delete []chunkWeight;
-        }
-         
-        numChunks = _numChunks;
-        cacheTable = new std::map<CkCacheKey,CkCacheEntry*>[numChunks];
-        chunkAck = new int[numChunks];
-        chunkAckWB = new int[numChunks];
-        chunkWeight = new CmiUInt8[numChunks];
-      }
-      for (int i=0; i<numChunks; ++i) {
-        chunkAck[i] = localChares.count;
-        chunkAckWB[i] = localCharesWB.count;
-        chunkWeight[i] = 0;
-      }
-      
-#if COSMO_STATS > 0
-      CmiResetMaxMemory();
-#endif
-    }
-
-    localIdx = localChares.registered.get(chareIdx);
-    CkAssert(localIdx != 0);
-  }
-
-  void CkCacheManager::writebackChunk(int chunk) {
-    CkAssert(chunkAckWB[chunk] > 0);
-    if (--chunkAckWB[chunk] == 0) {
-      // we can safely write back the chunk to the senders
-      // at this point no more changes to the data can be made until next fetch
-
-      std::map<CkCacheKey,CkCacheEntry*>::iterator iter;
-      for (iter = cacheTable[chunk].begin(); iter != cacheTable[chunk].end(); iter++) {
-        CkCacheEntry *e = iter->second;
-        e->writeback();
-      }
-
-    }
-  }
-
-  void CkCacheManager::finishedChunk(int chunk, CmiUInt8 weight) {
-    CkAssert(chunkAck[chunk] > 0);
-    chunkWeight[chunk] += weight;
-    //CkPrintf("Cache %d: finishedChunk %d\n",thisgroup.idx,chunkAck[chunk]);
-    if (--chunkAck[chunk] == 0) {
-      // we can safely delete the chunk from the cache
-      
-      // TODO: if chunks are held back due to restrictions, here is a
-      // good position to release them
-
-#if COSMO_STATS > 0
-      if (maxData < storedData) maxData = storedData;
-#endif
-
-      std::map<CkCacheKey,CkCacheEntry*>::iterator iter;
-      for (iter = cacheTable[chunk].begin(); iter != cacheTable[chunk].end(); iter++) {
-        CkCacheEntry *e = iter->second;
-        storedData -= e->type->size(e->data);
-        
-        // TODO: Store communication pattern here
-
-        delete e;
-      }
-      cacheTable[chunk].clear();
-      if (++finishedChunks == numChunks) {
-        finishedChunks = 0;
-        syncdChares = 0;
-      }
-    }
-  }
-  
-  CkReduction::reducerType CkCacheStatistics::sum;
-
-  void CkCacheManager::collectStatistics(CkCallback &cb) {
-#if COSMO_STATS > 0
-    CkCacheStatistics cs(dataArrived, dataTotalArrived,
-        dataMisses, dataLocal, dataError, totalDataRequested,
-        maxData, CkMyPe());
-    contribute(sizeof(CkCacheStatistics), &cs, CkCacheStatistics::sum, cb);
-#else
-    CkAbort("Invalid call, only valid if COSMO_STATS is defined");
-#endif
-  }
+CkReduction::reducerType CkCacheStatistics::sum;
 
 #include "CkCache.def.h"
index d8fac673670d540919c1e52b7b1e08ab1ef6765b..08fc482c2dabd835e2b7964fb1fc732bdc4e5a81 100644 (file)
@@ -1,17 +1,19 @@
 module CkCache {
-  message CkCacheRequestMsg;
-  message CkCacheFillMsg {
+  template<class CkCacheKey> message CkCacheRequestMsg;
+
+  template<class CkCacheKey> message CkCacheFillMsg {
     char data[];
   };
 
-  group [migratable] CkCacheManager {
+
+  template<class CkCacheKey> group [migratable] CkCacheManager {
     entry CkCacheManager(int size, CkGroupID gid);
     entry CkCacheManager(int size, int n, CkGroupID gid[n]);
     entry CkCacheManager(int size, int n, CkGroupID gid[n], int nWB, CkGroupID gidWB[nWB]);
     //entry [local] void * requestData(CkCacheKey what, CkArrayIndex &toWhom, int chunk, CkCacheEntryType *type, CkCacheRequestorData &req);
     //entry [local] void * requestDataNoFetch(CkCacheKey key, int chunk);
     entry [local] void cacheSync(int &numChunks, CkArrayIndex &chareIdx, int &localIdx);
-    entry void recvData(CkCacheFillMsg *msg);
+    entry void recvData(CkCacheFillMsg<CkCacheKey> *msg);
     //entry [local] void recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType *type, int chunk, void *data);
     entry void writebackChunk(int num);
     entry void finishedChunk(int num, CmiUInt8 weight);
@@ -19,4 +21,14 @@ module CkCache {
     //entry [local] std::map<CkCacheKey,CkCacheEntry*> *getCache();
     //entry [local] CkCacheEntry *requestCacheEntryNoFetch(CkCacheKey key, int chunk);
   };
+
+  message CkCacheFillMsg<CmiUInt8>;
+  message CkCacheRequestMsg<CmiUInt8>;
+  group CkCacheManager<CmiUInt8>;
+
+#if CMK_HAS_INT16
+  message CkCacheRequestMsg<CmiUInt16>;
+  message CkCacheFillMsg<CmiUInt16>;
+  group CkCacheManager<CmiUInt16>;
+#endif
 };
index 83d19d1e7a5f9d0ea66d311cba51880c4be5ec65..203da1194e0943b8a5e7e80b5c207b4c30228974 100644 (file)
@@ -19,7 +19,8 @@ It stores the index of the remote chare from
 which node is to be requested and the local
 chares that request it.***/
 
-typedef CmiUInt8 CkCacheKey;
+// template now
+//typedef CmiUInt8 CkCacheKey;
 
 typedef struct _CkCacheUserData {
   CmiUInt8 d0;
@@ -27,9 +28,9 @@ typedef struct _CkCacheUserData {
 } CkCacheUserData;
 
 
-class CkCacheEntryType;
-class CkCacheRequestorData;
-class CkCacheEntry;
+template<class CkCacheKey> class CkCacheEntryType;
+template<class CkCacheKey> class CkCacheRequestorData;
+template<class CkCacheKey> class CkCacheEntry;
 
 #include "CkCache.decl.h"
 
@@ -88,25 +89,28 @@ class CkCacheStatistics {
   }
 };
 
-class CkCacheRequestMsg : public CMessage_CkCacheRequestMsg {
+template<class CkCacheKey> 
+class CkCacheRequestMsg : public CMessage_CkCacheRequestMsg<CkCacheKey> {
  public:
   CkCacheKey key;
   int replyTo;
   CkCacheRequestMsg(CkCacheKey k, int reply) : key(k), replyTo(reply) { }
 };
 
-class CkCacheFillMsg : public CMessage_CkCacheFillMsg {
+template<class CkCacheKey>
+class CkCacheFillMsg : public CMessage_CkCacheFillMsg<CkCacheKey> {
 public:
   CkCacheKey key;
   char *data;
   CkCacheFillMsg (CkCacheKey k) : key(k) {}
 };
 
-typedef void (*CkCacheCallback)(CkArrayID, CkArrayIndex&, CkCacheKey, CkCacheUserData &, void*, int);
 
+template<class CkCacheKey>
 class CkCacheRequestorData {
 public:
   CkCacheUserData userData;
+  typedef void (*CkCacheCallback)(CkArrayID, CkArrayIndex&, CkCacheKey, CkCacheUserData &, void*, int);
   CkCacheCallback fn;
   CkArrayID requestorID;
   CkArrayIndex requestorIdx;
@@ -123,21 +127,23 @@ public:
   }
 };
 
+template<class CkCacheKey>
 class CkCacheEntryType {
 public:
   virtual void * request(CkArrayIndex&, CkCacheKey) = 0;
-  virtual void * unpack(CkCacheFillMsg *, int, CkArrayIndex &) = 0;
+  virtual void * unpack(CkCacheFillMsg<CkCacheKey> *, int, CkArrayIndex &) = 0;
   virtual void writeback(CkArrayIndex&, CkCacheKey, void *) = 0;
   virtual void free(void *) = 0;
   virtual int size(void *) = 0;
 };
 
+template<class CkCacheKey>
 class CkCacheEntry {
 public:
   CkCacheKey key;
   CkArrayIndex home;
-  CkCacheEntryType *type;
-  std::vector<CkCacheRequestorData> requestorVec;
+  CkCacheEntryType<CkCacheKey> *type;
+  std::vector< CkCacheRequestorData<CkCacheKey> > requestorVec;
 
   void *data;
   
@@ -151,7 +157,7 @@ public:
   /// to another TreePiece in the local processor we never miss
   int misses;
 #endif
-  CkCacheEntry(CkCacheKey key, CkArrayIndex &home, CkCacheEntryType *type) {
+  CkCacheEntry(CkCacheKey key, CkArrayIndex &home, CkCacheEntryType<CkCacheKey> *type) {
     replyRecvd = false;
     requestSent = false;
     writtenBack = false;
@@ -191,7 +197,8 @@ public:
   }
 };
 
-class CkCacheManager : public CBase_CkCacheManager {
+template<class CkCacheKey>
+class CkCacheManager : public CBase_CkCacheManager<CkCacheKey> {
 
   /***********************************************************************
    * Variables definitions
@@ -254,7 +261,7 @@ class CkCacheManager : public CBase_CkCacheManager {
   int *chunkAckWB;
 
   /// hash table containing all the entries currently in the cache
-  std::map<CkCacheKey,CkCacheEntry*> *cacheTable;
+  std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*> *cacheTable;
   int storedData;
 
   /// list of all the outstanding requests. The second field is the chunk for
@@ -270,18 +277,18 @@ class CkCacheManager : public CBase_CkCacheManager {
   CkCacheManager(int size, CkGroupID gid);
   CkCacheManager(int size, int n, CkGroupID *gid);
   CkCacheManager(int size, int n, CkGroupID *gid, int nWB, CkGroupID *gidWB);
-  CkCacheManager(CkMigrateMessage *m);
+  CkCacheManager(CkMigrateMessage *m): CBase_CkCacheManager<CkCacheKey>(m) { init(); }
   ~CkCacheManager() {}
   void pup(PUP::er &p);
  private:
   void init();
  public:
 
-  void * requestData(CkCacheKey what, CkArrayIndex &toWhom, int chunk, CkCacheEntryType *type, CkCacheRequestorData &req);
+  void * requestData(CkCacheKey what, CkArrayIndex &toWhom, int chunk, CkCacheEntryType<CkCacheKey> *type, CkCacheRequestorData<CkCacheKey> &req);
   void * requestDataNoFetch(CkCacheKey key, int chunk);
-  CkCacheEntry * requestCacheEntryNoFetch(CkCacheKey key, int chunk);
-  void recvData(CkCacheFillMsg *msg);
-  void recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType *type, int chunk, void *data);
+  CkCacheEntry<CkCacheKey> * requestCacheEntryNoFetch(CkCacheKey key, int chunk);
+  void recvData(CkCacheFillMsg<CkCacheKey> *msg);
+  void recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType<CkCacheKey> *type, int chunk, void *data);
 
   void cacheSync(int &numChunks, CkArrayIndex &chareIdx, int &localIdx);
 
@@ -296,8 +303,326 @@ class CkCacheManager : public CBase_CkCacheManager {
 
   /** Collect the statistics for the latest iteration */
   void collectStatistics(CkCallback& cb);
-  std::map<CkCacheKey,CkCacheEntry*> *getCache();
+  std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*> *getCache();
 
 };
 
+  // from CkCache.C
+
+  template<class CkCacheKey>
+  CkCacheManager<CkCacheKey>::CkCacheManager(int size, CkGroupID gid) {
+    init();
+    numLocMgr = 1;
+    numLocMgrWB = 0;
+    locMgr = new CkGroupID[1];
+    locMgr[0] = gid;
+    maxSize = (CmiUInt8)size * 1024 * 1024;
+  }
+
+  template<class CkCacheKey>
+  CkCacheManager<CkCacheKey>::CkCacheManager(int size, int n, CkGroupID *gid) {
+    init();
+    numLocMgr = n;
+    numLocMgrWB = 0;
+    locMgr = new CkGroupID[n];
+    for (int i=0; i<n; ++i) locMgr[i] = gid[i];
+    maxSize = (CmiUInt8)size * 1024 * 1024;
+  }
+
+  template<class CkCacheKey>
+  CkCacheManager<CkCacheKey>::CkCacheManager(int size, int n, CkGroupID *gid, int nWB, CkGroupID *gidWB) {
+    init();
+    numLocMgr = n;
+    locMgr = new CkGroupID[n];
+    for (int i=0; i<n; ++i) locMgr[i] = gid[i];
+    numLocMgrWB = nWB;
+    locMgrWB = new CkGroupID[nWB];
+    for (int i=0; i<n; ++i) locMgrWB[i] = gidWB[i];
+    maxSize = (CmiUInt8)size * 1024 * 1024;
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::init() {
+    numChunks = 0;
+    numLocMgr = 0;
+    locMgr = NULL;
+    maxSize = 0;
+    syncdChares = 0;
+    cacheTable = NULL;
+    chunkAck = NULL;
+    chunkWeight = NULL;
+    storedData = 0;
+#if COSMO_STATS > 0
+    dataArrived = 0;
+    dataTotalArrived = 0;
+    dataMisses = 0;
+    dataLocal = 0;
+    totalDataRequested = 0;
+#endif
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::pup(PUP::er &p) {
+    CBase_CkCacheManager<CkCacheKey>::pup(p);
+    p | numLocMgr;
+    if (p.isUnpacking()) locMgr = new CkGroupID[numLocMgr];
+    PUParray(p,locMgr,numLocMgr);
+    p | numLocMgrWB;
+    if (p.isUnpacking()) locMgrWB = new CkGroupID[numLocMgrWB];
+    PUParray(p,locMgrWB,numLocMgrWB);
+    p | maxSize;
+  }
+
+  template<class CkCacheKey>
+  void * CkCacheManager<CkCacheKey>::requestData(CkCacheKey what, CkArrayIndex &_toWhom, int chunk, CkCacheEntryType<CkCacheKey> *type, CkCacheRequestorData<CkCacheKey> &req)
+  {
+    typename std::map<CkCacheKey, CkCacheEntry<CkCacheKey>* >::iterator  p;
+    CkArrayIndex toWhom(_toWhom);
+    CkAssert(chunkAck[chunk] > 0);
+    p = cacheTable[chunk].find(what);
+    CkCacheEntry<CkCacheKey> *e;
+#if COSMO_STATS > 0
+    totalDataRequested++;
+#endif
+    if (p != cacheTable[chunk].end()) {
+      e = p->second;
+      CkAssert(e->home == toWhom);
+      //CkAssert(e->begin == begin);
+      //CkAssert(e->end == end);
+#if COSMO_STATS > 1
+      e->totalRequests++;
+#endif
+      if (e->data != NULL) {
+        return e->data;
+      }
+      if (!e->requestSent) {// || _nocache) {
+        e->requestSent = true;
+        if ((e->data = type->request(toWhom, what)) != NULL) {
+          e->replyRecvd = true;
+          return e->data;
+        }
+      }
+    } else {
+      e = new CkCacheEntry<CkCacheKey>(what, toWhom, type);
+#if COSMO_STATS > 1
+      e->totalRequests++;
+#endif
+      cacheTable[chunk][what] = e;
+      e->requestSent = true;
+      if ((e->data = type->request(toWhom, what)) != NULL) {
+        e->replyRecvd = true;
+        return e->data;
+      }
+    }
+
+    e->requestorVec.push_back(req);
+    outStandingRequests[what] = chunk;
+#if COSMO_STATS > 1
+    e->misses++;
+#endif
+    return NULL;
+  }
+
+  template<class CkCacheKey>
+  void * CkCacheManager<CkCacheKey>::requestDataNoFetch(CkCacheKey key, int chunk) {
+    typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey> *>::iterator p = cacheTable[chunk].find(key);
+    if (p != cacheTable[chunk].end()) {
+      return p->second->data;
+    }
+    return NULL;
+  }
+  
+  template<class CkCacheKey>
+  CkCacheEntry<CkCacheKey> * CkCacheManager<CkCacheKey>::requestCacheEntryNoFetch(CkCacheKey key, int chunk) {
+    typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey> *>::iterator p = cacheTable[chunk].find(key);
+    if (p != cacheTable[chunk].end()) {
+      return p->second;
+    }
+    return NULL;
+  }
+  
+  template<class CkCacheKey>
+  std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*> *CkCacheManager<CkCacheKey>::getCache(){
+    return cacheTable;
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::recvData(CkCacheFillMsg<CkCacheKey> *msg) {
+    CkCacheKey key = msg->key;
+    typename std::map<CkCacheKey,int>::iterator pchunk = outStandingRequests.find(key);
+    CkAssert(pchunk != outStandingRequests.end());
+    int chunk = pchunk->second;
+    CkAssert(chunk >= 0 && chunk < numChunks);
+    CkAssert(chunkAck[chunk] > 0);
+    outStandingRequests.erase(pchunk);
+    
+    typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*>::iterator p;
+    p = cacheTable[chunk].find(key);
+    CkAssert(p != cacheTable[chunk].end());
+    CkCacheEntry<CkCacheKey> *e = p->second;
+    e->data = e->type->unpack(msg, chunk, e->home);
+    storedData += e->type->size(e->data);
+    
+    typename std::vector<CkCacheRequestorData<CkCacheKey> >::iterator caller;
+    for (caller = e->requestorVec.begin(); caller != e->requestorVec.end(); caller++) {
+      caller->deliver(key, e->data, chunk);
+    }
+    e->requestorVec.clear();
+  }
+  
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType<CkCacheKey> *type, int chunk, void *data) {
+    typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*>::iterator p = cacheTable[chunk].find(key);
+    CkCacheEntry<CkCacheKey> *e;
+    if (p == cacheTable[chunk].end()) {
+      e = new CkCacheEntry<CkCacheKey>(key, from, type);
+      cacheTable[chunk][key] = e;
+    } else {
+      e = p->second;
+      storedData -= e->type->size(e->data);
+      e->type->writeback(e->home, e->key, e->data);
+    }
+    e->replyRecvd = true;
+    e->data = data;
+    storedData += e->type->size(data);
+    
+    typename std::vector<CkCacheRequestorData<CkCacheKey> >::iterator caller;
+    for (caller = e->requestorVec.begin(); caller != e->requestorVec.end(); caller++) {
+      caller->deliver(key, e->data, chunk);
+    }
+    e->requestorVec.clear();
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::cacheSync(int &_numChunks, CkArrayIndex &chareIdx, int &localIdx) {
+    finishedChunks = 0;
+    if (syncdChares > 0) {
+      _numChunks = numChunks;
+      //CkPrintf("Cache %d: sync following\n",thisgroup.idx);
+    } else {
+      syncdChares = 1;
+      //CkPrintf("Cache %d: sync\n",thisgroup.idx);
+
+      localChares.reset();
+      localCharesWB.reset();
+      for (int i=0; i<numLocMgr; ++i) {
+        CkLocMgr *mgr = (CkLocMgr *)CkLocalBranch(locMgr[i]);
+        mgr->iterate(localChares);
+      }
+      for (int i=0; i<numLocMgrWB; ++i) {
+        CkLocMgr *mgr = (CkLocMgr *)CkLocalBranch(locMgrWB[i]);
+        mgr->iterate(localChares);
+        mgr->iterate(localCharesWB);
+      }
+
+#if COSMO_STATS > 0
+      dataArrived = 0;
+      dataTotalArrived = 0;
+      dataMisses = 0;
+      dataLocal = 0;
+      totalDataRequested = 0;
+      maxData = 0;
+#endif
+
+      for (int chunk=0; chunk<numChunks; ++chunk) {
+        CkAssert(cacheTable[chunk].empty());
+        CkAssert(chunkAck[chunk]==0);
+        CkAssert(chunkAckWB[chunk]==0);
+      }
+      CkAssert(outStandingRequests.empty());
+      storedData = 0;
+
+      if (numChunks != _numChunks) {
+        if(numChunks != 0) {
+          delete []cacheTable;
+          delete []chunkAck;
+          delete []chunkAckWB;
+          delete []chunkWeight;
+        }
+         
+        numChunks = _numChunks;
+        cacheTable = new std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*>[numChunks];
+        chunkAck = new int[numChunks];
+        chunkAckWB = new int[numChunks];
+        chunkWeight = new CmiUInt8[numChunks];
+      }
+      for (int i=0; i<numChunks; ++i) {
+        chunkAck[i] = localChares.count;
+        chunkAckWB[i] = localCharesWB.count;
+        chunkWeight[i] = 0;
+      }
+      
+#if COSMO_STATS > 0
+      CmiResetMaxMemory();
+#endif
+    }
+
+    localIdx = localChares.registered.get(chareIdx);
+    CkAssert(localIdx != 0);
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::writebackChunk(int chunk) {
+    CkAssert(chunkAckWB[chunk] > 0);
+    if (--chunkAckWB[chunk] == 0) {
+      // we can safely write back the chunk to the senders
+      // at this point no more changes to the data can be made until next fetch
+
+      typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*>::iterator iter;
+      for (iter = cacheTable[chunk].begin(); iter != cacheTable[chunk].end(); iter++) {
+        CkCacheEntry<CkCacheKey> *e = iter->second;
+        e->writeback();
+      }
+
+    }
+  }
+
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::finishedChunk(int chunk, CmiUInt8 weight) {
+    CkAssert(chunkAck[chunk] > 0);
+    chunkWeight[chunk] += weight;
+    //CkPrintf("Cache %d: finishedChunk %d\n",thisgroup.idx,chunkAck[chunk]);
+    if (--chunkAck[chunk] == 0) {
+      // we can safely delete the chunk from the cache
+      
+      // TODO: if chunks are held back due to restrictions, here is a
+      // good position to release them
+
+#if COSMO_STATS > 0
+      if (maxData < storedData) maxData = storedData;
+#endif
+
+      typename std::map<CkCacheKey,CkCacheEntry<CkCacheKey>*>::iterator iter;
+      for (iter = cacheTable[chunk].begin(); iter != cacheTable[chunk].end(); iter++) {
+        CkCacheEntry<CkCacheKey> *e = iter->second;
+        storedData -= e->type->size(e->data);
+        
+        // TODO: Store communication pattern here
+
+        delete e;
+      }
+      cacheTable[chunk].clear();
+      if (++finishedChunks == numChunks) {
+        finishedChunks = 0;
+        syncdChares = 0;
+      }
+    }
+  }
+  
+  template<class CkCacheKey>
+  void CkCacheManager<CkCacheKey>::collectStatistics(CkCallback &cb) {
+#if COSMO_STATS > 0
+    CkCacheStatistics cs(dataArrived, dataTotalArrived,
+        dataMisses, dataLocal, dataError, totalDataRequested,
+        maxData, CkMyPe());
+    contribute(sizeof(CkCacheStatistics), &cs, CkCacheStatistics::sum, cb);
+#else
+    CkAbort("Invalid call, only valid if COSMO_STATS is defined");
+#endif
+  }
+
+#define CK_TEMPLATES_ONLY
+#include "CkCache.def.h"
+#undef CK_TEMPLATES_ONLY
+
 #endif
index 7a14076295734fdcffce1aa467a4f8962c469143..c67389e1d0f45bf9951a9f21e31958930a3e4e3e 100644 (file)
@@ -18,7 +18,7 @@ $(LIBDEST): $(LIBOBJ)
 CkCache.def.h CkCache.decl.h: INTERFACE
 
 INTERFACE: $(CIFILES)
-       $(CHARMC) -c CkCache.ci
+       $(CHARMC) -E -c CkCache.ci
        touch INTERFACE
 
 CkCache.o: CkCache.C $(HEADERS)
index a6658f6c939c7083136b9e441061fa58a782db7b..2d818631ef7ff2b8c6290978214f5403bb184181 100644 (file)
@@ -34,6 +34,8 @@ void CEntry::generateCode(XStr& decls, XStr& defs)
     if ((sv->isMsg != 1) && (sv->isVoid != 1)) {
        if (i >0)
          signature <<", ";
+       if (sv->byConst)
+         signature << "const ";
        signature << sv->type << " ";
        if (sv->arrayLength != 0)
          signature << "*";
index 1887fb0d65116b068a959970648e67fd21b810ed..13abe1a071894fa28bdb7c5190826dcec8c84288 100644 (file)
@@ -1419,6 +1419,9 @@ void generateSignature(XStr& decls, XStr& defs,
         if (count != 0)
           op << ", ";
 
+        // @TODO uncommenting this requires that PUP work on const types
+        //if (sv->byConst)
+        //op << "const ";
         if (sv->type != 0) 
           op <<sv->type <<" ";
         if (sv->byRef != 0)
index c0297fd43c77889127ed1808ed434b863e3755fe..42dddf47b3cc2eb9168cdf1b001241b0de4d32fb 100644 (file)
@@ -14,6 +14,7 @@ struct CStateVar {
     int numPtrs;
     XStr *name;
     XStr *byRef;
+    bool byConst;
     XStr *arrayLength;
     int isMsg;
 
@@ -28,9 +29,14 @@ struct CStateVar {
        }
 
 CStateVar(ParamList *pl)
-      : isVoid(0), type(new XStr(*(pl->param->getType()))), numPtrs(0),
-      name(new XStr(pl->getGivenName())), byRef(pl->isReference() ? new XStr("&") : NULL),
-      arrayLength(pl->isArray() ? new XStr(pl->getArrayLen()) : NULL), isMsg(pl->isMessage())
+      : isVoid(0)
+      , type(new XStr(*(pl->param->getType())))
+      , numPtrs(0)
+      , name(new XStr(pl->getGivenName()))
+      , byRef(pl->isReference() ? new XStr("&") : NULL)
+      , byConst(pl->isConst())
+      , arrayLength(pl->isArray() ? new XStr(pl->getArrayLen()) : NULL)
+      , isMsg(pl->isMessage())
       { }
 };
 
index 8db5ba079f6482b24699cc09cd3c93a005e615b5..6896eaea0068b5186069fe7458e5af8a01701e92 100644 (file)
@@ -2548,12 +2548,12 @@ yyreduce:
 
   case 73:
 #line 364 "xi-grammar.y"
-    { (yyval.type) = (yyvsp[(2) - (2)].type); }
+    { (yyval.type) = new ConstType((yyvsp[(2) - (2)].type)); }
     break;
 
   case 74:
 #line 366 "xi-grammar.y"
-    { (yyval.type) = (yyvsp[(1) - (2)].type); }
+    { (yyval.type) = new ConstType((yyvsp[(1) - (2)].type)); }
     break;
 
   case 75:
index 9f5509e8f8e60dc076d65dd4554bea6f846e7ff7..7b1714e5b2127758614b6d619b2c578f67b1238e 100644 (file)
@@ -361,9 +361,9 @@ BaseType    : SimpleType
                { $$ = $1; }
                //{ $$ = $1; }
                | CONST BaseType 
-               { $$ = $2; }
+               { $$ = new ConstType($2); }
                | BaseType CONST
-               { $$ = $1; }
+               { $$ = new ConstType($1); }
                ;
 
 Type           : BaseType '&'
index c40ff8664cf878cef19b74ebcc23df14fb073911..fdffa3964293dd391ee0ecd85080ffada32772c1 100644 (file)
@@ -4858,11 +4858,16 @@ into the message data-- so there's no copy on the receive side.
 The message is freed after the user entry returns.
 */
 Parameter::Parameter(int Nline,Type *Ntype,const char *Nname,
-       const char *NarrLen,Value *Nvalue)
-       :type(Ntype), name(Nname), arrLen(NarrLen), val(Nvalue),line(Nline)
+                     const char *NarrLen,Value *Nvalue)
+  : type(Ntype)
+  , name(Nname)
+  , arrLen(NarrLen)
+  , val(Nvalue)
+  , line(Nline)
+  , byConst(false)
+  , conditional(0)
+  , given_name(Nname)
 {
-        conditional=0;
-        given_name = Nname;
        if (isMessage()) {
                name="impl_msg";
         }
@@ -4885,6 +4890,10 @@ Parameter::Parameter(int Nline,Type *Ntype,const char *Nname,
                           it back ourselves in Parameter::print. */
                        type=type->deref();
                }
+                if (type->isConst()) {
+                  byConst = true;
+                  type = type->deref();
+                }
        }
 }
 
@@ -4910,12 +4919,14 @@ void Parameter::print(XStr &str,int withDefaultValues,int useConst)
            }
            else if (byReference)
                { //Pass named types by const C++ reference
-                       if (useConst) str<<"const ";
+                        if (useConst || byConst) str<<"const ";
                        str<<type<<" &";
                        if (name!=NULL) str<<name;
                }
                else
                { //Pass everything else by value
+                  // @TODO uncommenting this requires that PUP work on const types
+                  //if (byConst) str << "const ";
                        str<<type;
                        if (name!=NULL) str<<" "<<name;
                        if (withDefaultValues && val!=NULL)
index 5b713ed0a234b392339e1bf7f807ef95d7b58c63..adbdfe4b93d13f762ca377a20e3a39644ee63896 100644 (file)
@@ -156,6 +156,7 @@ class Type : public Printable {
     virtual int isCkMigMsgPtr(void) const {return 0;}
     virtual int isCkMigMsg(void) const {return 0;}
     virtual int isReference(void) const {return 0;}
+    virtual bool isConst(void) const {return false;}
     virtual Type *deref(void) {return this;}
     virtual const char *getBaseName(void) const = 0;
     virtual const char *getScope(void) const = 0;
@@ -246,6 +247,18 @@ class ReferenceType : public Type {
     const char *getScope(void) const { return NULL; }
 };
 
+class ConstType : public Type {
+private:
+  Type *constType;
+public:
+  ConstType(Type *t) : constType(t) {}
+  void print(XStr& str) {str << "const " << constType;}
+  virtual bool isConst(void) const {return true;}
+  virtual Type *deref(void) {return constType;}
+  const char *getBaseName(void) const { return constType->getBaseName(); }
+  const char *getScope(void) const { return NULL; }
+};
+
 //This is used as a list of base classes
 class TypeList : public Printable {
     Type *type;
@@ -271,6 +284,7 @@ class Parameter {
     int line;
     int byReference; //Fake a pass-by-reference (for efficiency)
     int conditional; //If the parameter is conditionally packed
+    bool byConst;
 
     // DMK - Added field for accelerator options
     int accelBufferType;
@@ -355,7 +369,8 @@ class ParamList {
     }
     const char *getArrayLen(void) const {return param->getArrayLen();}
     int isArray(void) const {return param->isArray();}
-    int isReference(void) const {return param->type->isReference();}
+    int isReference(void) const {return param->type->isReference() || param->byReference;}
+    bool isConst(void) const {return param->type->isConst() || param->byConst;}
     int isVoid(void) const {
        return (next==NULL) && param->isVoid();
     }
index e0ac09bbce3823e15b0cff6fec5e5685edd81c30..a5518d407c219d170dae697b803633f2ab0abd6a 100644 (file)
@@ -22,7 +22,7 @@ Orion Sky Lawlor, olawlor@acm.org, 2003/8/25
 */
 int testStack(int nKB,int useKB) {
        int i;
-#define buf1KB 1024-sizeof(i)
+#define buf1KB (1024-sizeof(i))
        char buf[buf1KB];
        for (i=0;i<buf1KB;i++)
                buf[i]=0;