Replace all occurrences of CkArrayIndexMax with CkArrayIndex
authorRamprasad Venkataraman <ramv@illinois.edu>
Wed, 1 Jun 2011 19:53:14 +0000 (14:53 -0500)
committerRamprasad Venkataraman <ramv@illinois.edu>
Wed, 8 Jun 2011 15:37:41 +0000 (10:37 -0500)
Leave a typedef behind so that applications that use CkArrayIndexMax can still
take their time to stop using it

70 files changed:
doc/charm++/arrays.tex
doc/charm++/commlib.tex
doc/charm++/delegation.tex
examples/charm++/X10/X10_test.decl.h
examples/charm++/commlib/multicast/pgm.C
examples/charm++/hello/xarraySection/hello.C
src/ck-com/AAMLearner.C
src/ck-com/AAPLearner.C
src/ck-com/ChunkMulticastStrategy.C
src/ck-com/ComlibArrayListener.C
src/ck-com/ComlibArrayListener.h
src/ck-com/ComlibManager.C
src/ck-com/ComlibManager.ci
src/ck-com/ComlibManager.h
src/ck-com/ComlibSectionInfo.C
src/ck-com/ComlibSectionInfo.h
src/ck-com/ComlibStrategy.C
src/ck-com/ComlibStrategy.h
src/ck-com/EachToManyMulticastStrategy.C
src/ck-com/EachToManyMulticastStrategy.h
src/ck-com/KDirectMulticastStrategy.C
src/ck-com/KDirectMulticastStrategy.h
src/ck-com/MsgPacker.h
src/ck-com/MulticastStrategy.C
src/ck-com/NodeMulticast.C
src/ck-com/NodeMulticast.h
src/ck-com/OneTimeMulticastStrategy.C
src/ck-com/RectMulticastStrategy.C
src/ck-com/RectMulticastStrategy.h
src/ck-core/charm++.h
src/ck-core/ck.C
src/ck-core/ckIgetControl.C
src/ck-core/ckIgetControl.h
src/ck-core/ckarray.C
src/ck-core/ckarray.h
src/ck-core/ckcausalmlog.C
src/ck-core/ckcausalmlog.h
src/ck-core/ckcheckpoint.C
src/ck-core/ckfutures.C
src/ck-core/cklocation.C
src/ck-core/cklocation.ci
src/ck-core/cklocation.h
src/ck-core/ckmemcheckpoint.C
src/ck-core/ckmemcheckpoint.ci
src/ck-core/ckmemcheckpoint.h
src/ck-core/ckmessagelogging.C
src/ck-core/ckmessagelogging.h
src/ck-core/cksection.h
src/ck-core/envelope.h
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/multicast/ckmulticast.C
src/libs/ck-libs/multicast/ckmulticast.ci
src/libs/ck-libs/multicast/ckmulticast.h
src/libs/ck-libs/taskGraph/taskGraph.C
src/libs/ck-libs/taskGraph/taskGraph.ci
src/libs/ck-libs/taskGraph/taskGraph.h
src/xlat-i/xi-symbol.C
tests/charm++/commtest/comlib/bench.C
tests/charm++/commtest/comlib/benchmulti.C
tests/charm++/commtest/comlib/benchsectionmulti.C
tests/charm++/commtest/eachtomany-simple/eachtomany.C
tests/charm++/commtest/eachtomany-test-2/eachtomany-Group.C
tests/charm++/commtest/eachtomany-test-2/eachtomany.C
tests/charm++/commtest/eachtomany/eachtomany.C
tests/charm++/delegation/1darray/hello.C
tests/charm++/delegation/1darray/hello.ci
tests/charm++/delegation/pipelined-section-reduction/hello.C
tests/charm++/megatest/multisectiontest.C

index a20d094244259716437bede6ac4b8caefd68a7c4..af1e7c20294804691a45a5f376c20b237d7c6f7d 100644 (file)
@@ -312,7 +312,7 @@ public:
   //...
   
   //Return an ``arrayHdl'', given some information about the array
-  virtual int registerArray(CkArrayIndexMax& numElements,CkArrayID aid);
+  virtual int registerArray(CkArrayIndex& numElements,CkArrayID aid);
   //Return the home processor number for this element of this array
   virtual int procNum(int arrayHdl,const CkArrayIndex &element);
 \}
@@ -327,7 +327,7 @@ class BlockMap : public CkArrayMap
  public:
   BlockMap(void) \{\}
   BlockMap(CkMigrateMessage *m)\{\}
-  int registerArray(CkArrayIndexMax& numElements,CkArrayID aid) \{
+  int registerArray(CkArrayIndex& numElements,CkArrayID aid) \{
     return 0;
   \}
   int procNum(int /*arrayHdl*/,const CkArrayIndex &idx) \{
@@ -819,10 +819,10 @@ The above codes create a section proxy that contains array elements of
 [0:9, 0:19:2, 0:29:2].
 
 For user-defined array index other than CkArrayIndex1D to CkArrayIndex6D,
-one needs to use the generic array index type: CkArrayIndexMax.
+one needs to use the generic array index type: CkArrayIndex.
 
 \begin{alltt}
-  CkArrayIndexMax *elems;    // add array indices
+  CkArrayIndex *elems;    // add array indices
   int numElems;
   CProxySection_Hello proxy = CProxySection_Hello::ckNew(helloArrayID, elems, numElems);
 \end{alltt}
@@ -1058,10 +1058,10 @@ arrays as follows:
          int aceiling=ArraySize-1;
          int asectionSize=aceiling-afloor+1;
          // cross section lower half of each array
-         CkArrayIndexMax **aelems= new CkArrayIndexMax*[3];
-         aelems[0]= new CkArrayIndexMax[asectionSize];
-         aelems[1]= new CkArrayIndexMax[asectionSize];
-         aelems[2]= new CkArrayIndexMax[asectionSize];
+         CkArrayIndex **aelems= new CkArrayIndex*[3];
+         aelems[0]= new CkArrayIndex[asectionSize];
+         aelems[1]= new CkArrayIndex[asectionSize];
+         aelems[2]= new CkArrayIndex[asectionSize];
          int *naelems=new int[3];
          for(int k=0;k<3;k++)
            \{
index 15693179be644a60b77b0d05cd756dfdca2a1b34..8902612dc45fa026d24496860906ad7607a97a3c 100644 (file)
@@ -397,8 +397,8 @@ EachToManyMulticastStrategy(int substrategy, int nsrcpes=0, int *srcpelist=0,
                             int ndestpes=0, int *destpelist=0);
 
 EachToManyMulticastStrategy(int substrategy, CkArrayID src, CkArrayID dest,
-                            int nsrc=0, CkArrayIndexMax *srcelements=0,
-                            int ndest=0, CkArrayIndexMax *destelements=0);
+                            int nsrc=0, CkArrayIndex *srcelements=0,
+                            int ndest=0, CkArrayIndex *destelements=0);
 \end{alltt}
 
 Both have as first parameter the virtual topology that the strategy will use for
index 2a8d01ccbf930d0d247c3490f58234b567ef4ef9..edae82e61c8de22114f3070b8f9e3aaa270bad1c 100644 (file)
@@ -93,8 +93,8 @@ public:
   virtual void NodeGroupSend(int ep,void *m,int onNode,CkNodeGroupID g);
   virtual void NodeGroupBroadcast(int ep,void *m,CkNodeGroupID g);
 
-  virtual void ArrayCreate(int ep,void *m,const CkArrayIndexMax &idx,int onPE,CkArrayID a);
-  virtual void ArraySend(int ep,void *m,const CkArrayIndexMax &idx,CkArrayID a);
+  virtual void ArrayCreate(int ep,void *m,const CkArrayIndex &idx,int onPE,CkArrayID a);
+  virtual void ArraySend(int ep,void *m,const CkArrayIndex &idx,CkArrayID a);
   virtual void ArrayBroadcast(int ep,void *m,CkArrayID a);
   virtual void ArraySectionSend(int ep,void *m,CkArrayID a,CkSectionID &s);
 };
index 15034809f9d754971619f33a55a2fca6904d825d..6a73d18de8d456b63d7eab6a12d7c596dd6778a1 100644 (file)
@@ -274,12 +274,12 @@ PUPmarshall(CProxy_Places);
       for (int i=l; i<=u; i+=s) al.push_back(CkArrayIndex1D(i));
       return CkSectionID(aid, al.getVec(), al.size());
     } 
-    CProxySection_Places(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems, CK_DELCTOR_PARAM) 
+    CProxySection_Places(const CkArrayID &aid, CkArrayIndex *elems, int nElems, CK_DELCTOR_PARAM) 
         :CProxySection_ArrayElement(aid,elems,nElems,CK_DELCTOR_ARGS) {}
-    CProxySection_Places(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems) 
+    CProxySection_Places(const CkArrayID &aid, CkArrayIndex *elems, int nElems) 
         :CProxySection_ArrayElement(aid,elems,nElems) {}
     CProxySection_Places(const CkSectionID &sid)       :CProxySection_ArrayElement(sid) {}
-    static CkSectionID ckNew(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems) {
+    static CkSectionID ckNew(const CkArrayID &aid, CkArrayIndex *elems, int nElems) {
       return CkSectionID(aid, elems, nElems);
     } 
 /* DECLS: Places(CkMigrateMessage* impl_msg);
index a81919f92ce7207db007ac4b39c589c276ffca7b..f64736696e095f9c31ed4677502d17e0c51eb950 100644 (file)
@@ -103,7 +103,7 @@ void Main::done() {
 
 
 Source::Source(int n, int *indices) {
-  CkArrayIndexMax *elems = (CkArrayIndexMax*) alloca(n * sizeof(CkArrayIndexMax));
+  CkArrayIndex *elems = (CkArrayIndex*) alloca(n * sizeof(CkArrayIndex));
   for (int i=0; i<n; ++i) elems[i] = CkArrayIndex1D(indices[i]);
 
   /* Create the ProxySections and associate them with the three different
index 88560ce42be00c027d8560caad4ea7f9b31b91a2..f7c56c90b1dbce5741d8003e5d07e369397073e7 100644 (file)
@@ -40,7 +40,7 @@ public:
     CProxy_Hello *arrayOfArrays = new CProxy_Hello[numArrays];
     CkArrayID *arrID            = new CkArrayID[numArrays];
     int *nelems                 = new int[numArrays];
-    CkArrayIndexMax **elems     = new CkArrayIndexMax*[numArrays];
+    CkArrayIndex **elems     = new CkArrayIndex*[numArrays];
 
     // Create a list of array section members
     for(int k=0; k < numArrays; k++)
@@ -51,7 +51,7 @@ public:
         arrID[k]  = arrayOfArrays[k].ckGetArrayID();
         // Create a list of section member indices in this array
         nelems[k] = sectionSize;
-        elems[k]  = new CkArrayIndexMax[sectionSize];
+        elems[k]  = new CkArrayIndex[sectionSize];
         for(int i=afloor,j=0; i <= aceiling; i++,j++)
             elems[k][j] = CkArrayIndex1D(i);
     }
index 967eca875a1b9f769f07e7d273d9824f1dbee4a6..384e7100a4292f656e386a6a56c6e2442daec110 100644 (file)
@@ -35,7 +35,7 @@
 //     int minstrat = -1;
 //     if(in_strat->getType() == ARRAY_STRATEGY) {
 //         CkArrayID said, daid;
-//         CkArrayIndexMax *sidxlist, *didxlist;
+//         CkArrayIndex *sidxlist, *didxlist;
 //         int nsrc, ndest;
         
 //         in_strat->ainfo.getSourceArray(said, sidxlist, nsrc);
index 066ea54957f06372815deaa3a82620bf0686ab7e..dd67731fc2dc3792a5449babbcc1fa33cc790f44 100644 (file)
@@ -57,7 +57,7 @@
     
 //     if(in_strat->getType() == ARRAY_STRATEGY) {
 //         CkArrayID said, daid;
-//         CkArrayIndexMax *sidxlist, *didxlist;
+//         CkArrayIndex *sidxlist, *didxlist;
 //         int nsrc, ndest;
         
 //         in_strat->ainfo.getSourceArray(said, sidxlist, nsrc);
index ad2946058ec930f22a5e8bca0bc85a7d40e05a55..104cb85b87c14b042a08a70d028bb37a428e4698 100644 (file)
@@ -159,7 +159,7 @@ void ChunkMulticastStrategy::insertMessage(CharmMessageHolder *cmsg){
 void ChunkMulticastStrategy::localMulticast(CharmMessageHolder *cmsg) {
   double start = CmiWallTimer();
   CkSectionID *sec_id = cmsg->sec_id;
-  CkVec< CkArrayIndexMax > localIndices;
+  CkVec< CkArrayIndex > localIndices;
   sinfo.getLocalIndices(sec_id->_nElems, sec_id->_elems, sec_id->_cookie.aid, localIndices);
   deliverToIndices(cmsg->getCharmMessage(), localIndices.size(), localIndices.getVec() );
   //if (deliverToIndices(cmsg->getCharmMessage(), localIndices.size(), localIndices.getVec() ) == 0) 
@@ -275,7 +275,7 @@ void ChunkMulticastStrategy::handleMessage(void *msg){
   // Deliver to objects marked as local in the message
   int localElems;
   envelope *newenv;
-  CkArrayIndexMax *local_idx_list;  
+  CkArrayIndex *local_idx_list;  
   sinfo.unpack(env, localElems, local_idx_list, newenv);
   ComlibMulticastMsg *newmsg = (ComlibMulticastMsg *)EnvToUsr(newenv);  
 
index b6effc8371b953bddd2b3722e6393903b4ca1adb..ff7e5623f2333db9128d69c69b63cb526b334e89 100644 (file)
@@ -15,7 +15,7 @@
 //ComlibArrayListener::ComlibArrayListener () 
 //    : CkArrayListener(0){ //Carry 1 int for the sid, not used yet
 //    nElements = 0;
-//    ht = new CkHashtableT<CkArrayIndexMax, CkArrayIndexMax *>;
+//    ht = new CkHashtableT<CkArrayIndex, CkArrayIndex *>;
 //    //    CkPrintf("Creating Array Listener\n");
 //}
 //*/
@@ -30,7 +30,7 @@
 //    :CkArrayListener(m) {
 //  /*
 //    nElements = 0;
-//    ht = new CkHashtableT<CkArrayIndexMax, CkArrayIndexMax *>;
+//    ht = new CkHashtableT<CkArrayIndex, CkArrayIndex *>;
 //  */
 //}
 //
 //
 //int ComlibArrayListener::isRegistered(ArrayElement *elt, 
 //                                      CharmStrategy *strat){
-//    CkArrayIndexMax idx = elt->thisIndexMax;
+//    CkArrayIndex idx = elt->thisIndexMax;
 //
 //    CkArrayID st_aid;
 //    int st_nelements;
-//    CkArrayIndexMax *st_elem;
+//    CkArrayIndex *st_elem;
 //    strat->ainfo.getSourceArray(st_aid, st_elem, st_nelements);
 //
 //    if(st_nelements < 0)
 //
 //    CkArrayID st_aid;
 //    int st_nelements;
-//    CkArrayIndexMax *st_elem;
+//    CkArrayIndex *st_elem;
 //    strat->ainfo.getSourceArray(st_aid, st_elem, st_nelements);
 //
 //    if(st_nelements == 0) {//All elements of array in strategy
 ////         CkHashtableIterator *ht_iterator = ht->iterator();
 ////         ht_iterator->seekStart();
 ////         while(ht_iterator->hasNext()){
-////             CkArrayIndexMax *idx;
+////             CkArrayIndex *idx;
 ////             ht_iterator->next((void **)&idx);
 ////             stable_entry->strategy->insertLocalIndex(*idx);       
 ////         }
 //
 //}
 //
-//void ComlibArrayListener::getLocalIndices(CkVec<CkArrayIndexMax> &vec){
+//void ComlibArrayListener::getLocalIndices(CkVec<CkArrayIndex> &vec){
 //    
 //    CkHashtableIterator *ht_iterator = ht->iterator();
 //    ht_iterator->seekStart();
 //    while(ht_iterator->hasNext()){
-//        CkArrayIndexMax *idx;
+//        CkArrayIndex *idx;
 //        ht_iterator->next((void **)&idx);
 //        vec.insertAtEnd(*idx);       
 //    }
index 7cae1b75f67e2e57e67d011fe9942d2f7a292056..8b31194b960fa25eeb9dcda1dbe3ecc8c6b4022c 100644 (file)
@@ -21,7 +21,7 @@
 //  CkArrayID thisArrayID;
 //  /*
 //  CkVec <StrategyTableEntry *> strategyList;
-//  CkHashtableT<CkArrayIndexMax, CkArrayIndexMax*> *ht;
+//  CkHashtableT<CkArrayIndex, CkArrayIndex*> *ht;
 //    
 //  int isRegistered(ArrayElement *elt, CharmStrategy *astrat);
 //  void addElement(ArrayElement *elt, CmiBool mogration_flag);
@@ -68,7 +68,7 @@
 //     strategyList.remove(count);
 //  }
 //
-//  void getLocalIndices(CkVec<CkArrayIndexMax> &vec);
+//  void getLocalIndices(CkVec<CkArrayIndex> &vec);
 //  */
 //
 //  void pup(PUP::er &p);
index d09d92e2d4a25fb1513fd5cd97a621fcb8d22d7e..62572abb182d6533670d0ca1c551e7006d70e4dc 100644 (file)
@@ -692,7 +692,7 @@ void ComlibManager::bracketedStartDiscovery(int instid) {
 
        if (myInfo->isSourceArray()) {
 
-         const CkVec<CkArrayIndexMax> & srcElements = myInfo->getSourceElements();
+         const CkVec<CkArrayIndex> & srcElements = myInfo->getSourceElements();
          const int nelem = srcElements.size();
          const CkArrayID aid = myInfo->getSourceArrayID(); 
          const CkArray *a = (CkArray*)_localBranch(aid);
@@ -713,7 +713,7 @@ void ComlibManager::bracketedStartDiscovery(int instid) {
        if (myInfo->isDestinationArray()) {
 //       CkAssert(myInfo->newDestinationListSize() == 0);
 
-         const CkVec<CkArrayIndexMax> & destElements = myInfo->getDestinationElements();
+         const CkVec<CkArrayIndex> & destElements = myInfo->getDestinationElements();
          const int nelem = destElements.size();
          const CkArrayID aid = myInfo->getDestinationArrayID();
          const CkArray *a = (CkArray*)_localBranch(aid);
@@ -752,7 +752,7 @@ void ComlibManager::bracketedStartDiscovery(int instid) {
     known location for the element.
 
 */
-void ComlibManager::bracketedDiscover(int instid, CkArrayID aid, CkArrayIndexMax &idx, int isSrc) {
+void ComlibManager::bracketedDiscover(int instid, CkArrayID aid, CkArrayIndex &idx, int isSrc) {
        ComlibManagerPrintf("[%d] bracketedDiscover\n", CkMyPe());
        CkArray *a = (CkArray *)_localBranch(aid);
        int pe = a->lastKnown(idx);
@@ -902,7 +902,7 @@ void msg_prepareSend_noinline(CkArrayMessage *msg, int ep,CkArrayID aid);
 
  */
 void ComlibManager::ArraySend(CkDelegateData *pd,int ep, void *msg, 
-               const CkArrayIndexMax &idx, CkArrayID a){
+               const CkArrayIndex &idx, CkArrayID a){
 
        CkAssert(pd != NULL);
        ComlibDelegateData *ci = static_cast<ComlibDelegateData *>(pd);
index b4b8fe0f15071190b7b0a6693e7243f48c22f6df..aad14fca0100f69a94288858c43d47e68cd12f1c 100644 (file)
@@ -5,7 +5,7 @@ module comlib {
   message ComlibDummyMsg;
   message ComlibMulticastMsg {
     ComlibMulticastIndexCount indicesCount[];
-    CkArrayIndexMax indices[];
+    CkArrayIndex indices[];
     char usrMsg[];
   };
   //  message PrioMsg;
@@ -22,7 +22,7 @@ module comlib {
     entry void bracketedConfirmCount(int instid, int step);
     entry void bracketedCountConfirmed(int instid, int count, int step);
     entry void bracketedReceiveNewCount(int instid, int step);
-    entry void bracketedDiscover(int instid, CkArrayID aid, CkArrayIndexMax &idx, int isSrc);
+    entry void bracketedDiscover(int instid, CkArrayID aid, CkArrayIndex &idx, int isSrc);
     entry void bracketedContributeDiscovery(int instid, int pe, int nsrc, int ndest, int step);
     entry void bracketedReceiveNewPeList(int instid, int step, int count[CkNumPes()]);
     entry void bracketedReleaseCount(int instid, int step);
index d68a4edc9bcbf6c9e7ef5a90c7806b35d17fd1c4..4ff5796ee22c8d4895ece9b6e845d17dc8906ff3 100644 (file)
@@ -199,7 +199,7 @@ class ComlibMulticastMsg : public CkMcastBaseMsg,
   public:
     int nPes;
     ComlibMulticastIndexCount *indicesCount;
-    CkArrayIndexMax *indices;
+    CkArrayIndex *indices;
     char *usrMsg;        
 };
 
@@ -240,7 +240,7 @@ class ComlibManager: public CkDelegateMgr {
     /// Used to register and record events into projection
     int section_send_event;
 
-    CkArrayIndexMax dummyArrayIndex;
+    CkArrayIndex dummyArrayIndex;
 
     /// Pointer to the converse comlib object, for efficiency over calling CkpvAccess
     ConvComlibManager *converseManager;
@@ -310,7 +310,7 @@ class ComlibManager: public CkDelegateMgr {
     /* The delegation framework reimplemented functions */
 
     void ArraySend(CkDelegateData *pd,int ep, void *msg, 
-                   const CkArrayIndexMax &idx, CkArrayID a);
+                   const CkArrayIndex &idx, CkArrayID a);
     void GroupSend(CkDelegateData *pd, int ep, void *msg, int onpe, 
                    CkGroupID gid);
     void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
@@ -348,7 +348,7 @@ class ComlibManager: public CkDelegateMgr {
     void bracketedReleaseBufferedMessages(int instid, int step);
 
     void bracketedStartDiscovery(int instid);
-    void bracketedDiscover(int instid, CkArrayID aid, CkArrayIndexMax &idx, int isSrc);
+    void bracketedDiscover(int instid, CkArrayID aid, CkArrayIndex &idx, int isSrc);
     void bracketedContributeDiscovery(int instid, int pe, int nsrc, int ndest, int step);
 
 
index db5682d97fed25fe40a84ec8005a8764515971d4..1ebb39d17f8c0ef8052fe3ab169bdf30ec090c4b 100644 (file)
@@ -78,9 +78,9 @@ ComlibMulticastMsg * ComlibSectionInfo::getNewMulticastMessage(CharmMessageHolde
 
     // fill in the three pointers of the ComlibMulticastMsg
     memcpy(msg->indicesCount, indicesCount, sizes[0] * sizeof(ComlibMulticastIndexCount));
-    //memcpy(msg->indices, cmsg->sec_id->_elems, sizes[1] * sizeof(CkArrayIndexMax));
+    //memcpy(msg->indices, cmsg->sec_id->_elems, sizes[1] * sizeof(CkArrayIndex));
 
-    CkArrayIndexMax **indicesPe = (CkArrayIndexMax**)alloca(nRemotePes * sizeof(CkArrayIndexMax*));
+    CkArrayIndex **indicesPe = (CkArrayIndex**)alloca(nRemotePes * sizeof(CkArrayIndex*));
 
     if (needSort) {
        // if we are sorting the array, then we need to fix the problem that belongingList
@@ -142,7 +142,7 @@ void ComlibSectionInfo::getPeList(envelope *cb_env, int npes, int *&pelist)
 
 void ComlibSectionInfo::unpack(envelope *cb_env,
                               int &nLocalElems,
-                               CkArrayIndexMax *&dest_indices, 
+                               CkArrayIndex *&dest_indices, 
                                envelope *&env) {
         
     ComlibMulticastMsg *ccmsg = (ComlibMulticastMsg *)EnvToUsr(cb_env);
@@ -170,7 +170,7 @@ void ComlibSectionInfo::unpack(envelope *cb_env,
     */
     /*
     for(int count = 0; count < ccmsg->nIndices; count++){
-        CkArrayIndexMax idx = ccmsg->indices[count];
+        CkArrayIndex idx = ccmsg->indices[count];
         
         //This will work because. lastknown always knows if I have the
         //element of not
@@ -211,7 +211,7 @@ CkMcastBaseMsg *ComlibSectionInfo::getNewDeliveryErrorMsg(CkMcastBaseMsg *base)
 }
 
 void ComlibSectionInfo::getPeList(int _nElems, 
-                                  CkArrayIndexMax *_elems,
+                                  CkArrayIndex *_elems,
                                  CkArrayID &destArrayID,
                                   int &npes, int *&pelist){
 
@@ -294,7 +294,7 @@ inline int getPErepresentingNodeContainingPE(int pe){
        2) belongs -- belongs[i] points to the owning pe's entry in the "counts" array.
        
 */
-void ComlibSectionInfo::getPeCount(int nindices, CkArrayIndexMax *idxlist, 
+void ComlibSectionInfo::getPeCount(int nindices, CkArrayIndex *idxlist, 
                      const CkArrayID &destArrayID, int &npes, int &nidx,
                      ComlibMulticastIndexCount *&counts, int *&belongs) {
 
@@ -358,7 +358,7 @@ void ComlibSectionInfo::getPeCount(int nindices, CkArrayIndexMax *idxlist,
 
 
 void ComlibSectionInfo::getRemotePelist(int nindices, 
-                                        CkArrayIndexMax *idxlist,
+                                        CkArrayIndex *idxlist,
                                        CkArrayID &destArrayID,
                                         int &npes, int *&pelist) {
 
@@ -413,9 +413,9 @@ void ComlibSectionInfo::getRemotePelist(int nindices,
 
 
 void ComlibSectionInfo::getLocalIndices(int nindices,
-                                        CkArrayIndexMax *idxlist,
+                                        CkArrayIndex *idxlist,
                                        CkArrayID &destArrayID,
-                                        CkVec<CkArrayIndexMax> &idx_vec){    
+                                        CkVec<CkArrayIndex> &idx_vec){    
        ComlibPrintf("ComlibSectionInfo::getLocalIndices()\n");
        
        int count = 0, acount = 0;
@@ -433,9 +433,9 @@ void ComlibSectionInfo::getLocalIndices(int nindices,
 
 
 void ComlibSectionInfo::getNodeLocalIndices(int nindices,
-                                        CkArrayIndexMax *idxlist,
+                                        CkArrayIndex *idxlist,
                                        CkArrayID &destArrayID,
-                                        CkVec<CkArrayIndexMax> &idx_vec){    
+                                        CkVec<CkArrayIndex> &idx_vec){    
     int count = 0, acount = 0;
     idx_vec.resize(0);
     
index f30d8c53b7f120537120af3adb6630f8f5fdf764..6140c6be0e5e605899d7cb02c6530521c9cf2017 100644 (file)
@@ -85,7 +85,7 @@ inline CkHashCode ComlibSectionHashKey::staticHash(const void *v,size_t){
 class ComlibSectionHashObject {
  public:
     //My local indices
-    CkVec<CkArrayIndexMax> indices;
+    CkVec<CkArrayIndex> indices;
     
     //Other processors to send this message to
     int npes;
@@ -169,7 +169,7 @@ class ComlibSectionInfo {
      * elements are local. env is a new allocated memory containing the user
      * message.
      */
-    void unpack(envelope *cb_env, int &nLocalElems, CkArrayIndexMax *&destIndices, 
+    void unpack(envelope *cb_env, int &nLocalElems, CkArrayIndex *&destIndices, 
                 envelope *&env);
 
     void localMulticast(envelope *env);
@@ -187,7 +187,7 @@ class ComlibSectionInfo {
      * @param counts array of associations pe-count: number of elements in proc pe (output, new'ed(CkNumPes()))
      * @param belongs array of integers expressing association of elements with pes: belongs[i] = index in counts of the processor having index i (output, new'ed(nindices))
     */
-    void getPeCount(int nindices, CkArrayIndexMax *idxlist, const CkArrayID &destArrayID,
+    void getPeCount(int nindices, CkArrayIndex *idxlist, const CkArrayID &destArrayID,
                    int &npes, int &nidx,
                    ComlibMulticastIndexCount *&counts, int *&belongs);
 
@@ -203,19 +203,19 @@ class ComlibSectionInfo {
      * @param npes number of processors involved (output)
      * @param pelist list of the processors involved (output, new'ed)
      */
-    void getRemotePelist(int nindices, CkArrayIndexMax *idxlist, CkArrayID &destArrayID,
+    void getRemotePelist(int nindices, CkArrayIndex *idxlist, CkArrayID &destArrayID,
                          int &npes, int *&pelist);
 
     /** Returns the same list as getRemotePeList, only that it does not exclude
        the local processor from the list if it is involved. */
-    void getPeList(int nindices, CkArrayIndexMax *idxlist, CkArrayID &destArrayID,
+    void getPeList(int nindices, CkArrayIndex *idxlist, CkArrayID &destArrayID,
                    int &npes, int *&pelist);
 
-    void getLocalIndices(int nindices, CkArrayIndexMax *idxlist, CkArrayID &destArrayID,
-                         CkVec<CkArrayIndexMax> &idx_vec);   
+    void getLocalIndices(int nindices, CkArrayIndex *idxlist, CkArrayID &destArrayID,
+                         CkVec<CkArrayIndex> &idx_vec);   
         
-    void getNodeLocalIndices(int nindices, CkArrayIndexMax *idxlist, CkArrayID &destArrayID,
-                         CkVec<CkArrayIndexMax> &idx_vec);   
+    void getNodeLocalIndices(int nindices, CkArrayIndex *idxlist, CkArrayID &destArrayID,
+                         CkVec<CkArrayIndex> &idx_vec);   
         
     void pup(PUP::er &p) {
         p | MaxSectionID;
index 86fada3b51f2289cb1584174a36a9e693cc87f1f..6278bff94fb519602fd3ea817cfc6b4b034e1c42 100644 (file)
@@ -31,7 +31,7 @@ void CharmStrategy::pup(PUP::er &p) {
     @return the number of destination objects which were not local (information
     retrieved from the array/location manager)
 */
-int CharmStrategy::deliverToIndices(void *msg, int numDestIdxs, const CkArrayIndexMax* indices ){
+int CharmStrategy::deliverToIndices(void *msg, int numDestIdxs, const CkArrayIndex* indices ){
   int count = 0;
   
   envelope *env = UsrToEnv(msg);
@@ -246,7 +246,7 @@ ComlibArrayInfo::ComlibArrayInfo() {
 }
 
 
-void ComlibArrayInfo::setSourceArray(CkArrayID aid, CkArrayIndexMax *e, int nind){
+void ComlibArrayInfo::setSourceArray(CkArrayID aid, CkArrayIndex *e, int nind){
     src_aid = aid;
     isSrcArray = 1;
 
@@ -268,7 +268,7 @@ void ComlibArrayInfo::setSourceArray(CkArrayID aid, CkArrayIndexMax *e, int nind
 }
 
 
-void ComlibArrayInfo::setDestinationArray(CkArrayID aid, CkArrayIndexMax *e, int nind){
+void ComlibArrayInfo::setDestinationArray(CkArrayID aid, CkArrayIndex *e, int nind){
   ComlibPrintf("[%d] ComlibArrayInfo::setDestinationArray  dest_elements\n", CkMyPe());
     dest_aid = aid;
     isDestArray = 1;
@@ -417,7 +417,7 @@ void ComlibArrayInfo::localBroadcast(envelope *env) {
 
 */
 #include "register.h"
-int ComlibArrayInfo::localMulticast(CkVec<CkArrayIndexMax>*vec,
+int ComlibArrayInfo::localMulticast(CkVec<CkArrayIndex>*vec,
                                      envelope *env){
   int count = 0;
     //Multicast the messages to all elements in vec
@@ -436,7 +436,7 @@ int ComlibArrayInfo::localMulticast(CkVec<CkArrayIndexMax>*vec,
     env->getsetArrayHops()=1;
     env->setUsed(0);
 
-    CkArrayIndexMax idx;
+    CkArrayIndex idx;
 
     //ComlibPrintf("sending to %d elements\n",nelements);
     for(int i = 0; i < nelements-1; i ++){
index 10c0845f02b5222a4ef499e2d56bb4dee32ca193..c57af73f7f21124634419b9f739c5b09bb21eb87 100644 (file)
@@ -104,7 +104,7 @@ class CharmMessageHolder : public MessageHolder{
 
        // Create a new CkSectionID, allocating its members
        copy_of_sec_id = new CkSectionID();
-       copy_of_sec_id->_elems = new CkArrayIndexMax[sec_id->_nElems];
+       copy_of_sec_id->_elems = new CkArrayIndex[sec_id->_nElems];
        copy_of_sec_id->pelist = new int[sec_id->npes];
        
        // Copy in the values
@@ -218,24 +218,24 @@ class ComlibArrayInfo {
     /**  Destination indices that are local to this PE 
         (as determined by the bracketed counting scheme from a previous iteration)  
     */
-    CkVec<CkArrayIndexMax> src_elements; 
+    CkVec<CkArrayIndex> src_elements; 
 
     /**  Destination indices that are currently being updated. 
         At the beginning of the next iteration these will be 
         moved into dest_elements by useNewDestinationList()
     */
-    CkVec<CkArrayIndexMax> new_src_elements;
+    CkVec<CkArrayIndex> new_src_elements;
 
     /**  Destination indices that are local to this PE 
         (as determined by the bracketed counting scheme from a previous iteration)  
     */
-    CkVec<CkArrayIndexMax> dest_elements; 
+    CkVec<CkArrayIndex> dest_elements; 
 
     /**  Destination indices that are currently being updated. 
         At the beginning of the next iteration these will be 
         moved into dest_elements by useNewDestinationList()
     */
-    CkVec<CkArrayIndexMax> new_dest_elements;
+    CkVec<CkArrayIndex> new_dest_elements;
 
     int isSrcArray;
     int isDestArray;
@@ -253,32 +253,32 @@ class ComlibArrayInfo {
        The list of array indices should be the whole portion of the array involved in the strategy.
        The non-local array elements will be cleaned up inside purge() at migration of the strategy
     */
-    void setSourceArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
+    void setSourceArray(CkArrayID aid, CkArrayIndex *e=0, int nind=0);
     int isSourceArray(){return isSrcArray;}
     CkArrayID getSourceArrayID() {return src_aid;}
-    const CkVec<CkArrayIndexMax> & getSourceElements() {return src_elements;}
+    const CkVec<CkArrayIndex> & getSourceElements() {return src_elements;}
 
     /** Set the destination array used for this strategy. 
        The list of array indices should be the whole portion of the array involved in the strategy.
        The non-local array elements will be cleaned up inside purge() at migration of the strategy
     */
-    void setDestinationArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
+    void setDestinationArray(CkArrayID aid, CkArrayIndex *e=0, int nind=0);
     int isDestinationArray(){return isDestArray;}
     CkArrayID getDestinationArrayID() {return dest_aid;}
-    const CkVec<CkArrayIndexMax> & getDestinationElements() {return dest_elements;}
+    const CkVec<CkArrayIndex> & getDestinationElements() {return dest_elements;}
 
     /// Get the number of source array elements
     int getTotalSrc() {return totalSrc;}
     int getLocalSrc() {return src_elements.size();}
 
     /** Add a destination object that is local to this PE to list used in future iterations */
-    void addNewLocalDestination(const CkArrayIndexMax &e) {
+    void addNewLocalDestination(const CkArrayIndex &e) {
         CkAssert(e.nInts > 0);
        new_dest_elements.push_back(e);
     }
 
     /** Add a source object that is local to this PE to list used in future iterations */
-    void addNewLocalSource(const CkArrayIndexMax &e) {
+    void addNewLocalSource(const CkArrayIndex &e) {
         CkAssert(e.nInts > 0);
        new_src_elements.push_back(e);
     }
@@ -307,7 +307,7 @@ class ComlibArrayInfo {
     void newElement(CkArrayID &id, const CkArrayIndex &idx);
 
     void localBroadcast(envelope *env);
-    static int localMulticast(CkVec<CkArrayIndexMax> *idx_vec,envelope *env);
+    static int localMulticast(CkVec<CkArrayIndex> *idx_vec,envelope *env);
     static void deliver(envelope *env);
 
     /// This routine is called only once at the beginning and will take the list
@@ -329,9 +329,9 @@ class ComlibArrayInfo {
     specified processor. Currently used by ComlibArrayInfo */
 class ComlibElementIterator : public CkLocIterator {
  public:
-  CkVec<CkArrayIndexMax> *list;
+  CkVec<CkArrayIndex> *list;
 
-  ComlibElementIterator(CkVec<CkArrayIndexMax> *l) : CkLocIterator() {
+  ComlibElementIterator(CkVec<CkArrayIndex> *l) : CkLocIterator() {
     list = l;
   }
 
@@ -360,10 +360,10 @@ class CharmStrategy {
 
 
     /** Deliver a message to a set of indices using the array manager. Indices can be local or remote. */
-    int deliverToIndices(void *msg, int numDestIdxs, const CkArrayIndexMax* indices );
+    int deliverToIndices(void *msg, int numDestIdxs, const CkArrayIndex* indices );
     
     /** Deliver a message to a set of indices using the array manager. Indices can be local or remote. */
-    inline void deliverToIndices(void *msg, const CkVec< CkArrayIndexMax > &indices ){
+    inline void deliverToIndices(void *msg, const CkVec< CkArrayIndex > &indices ){
       deliverToIndices(msg, indices.size(), indices.getVec() );
     }
     
@@ -417,7 +417,7 @@ class CharmStrategy {
 
 //API calls which will be valid when communication library is not linked
 void ComlibNotifyMigrationDone();
-//int ComlibGetLastKnown(CkArrayID aid, CkArrayIndexMax idx);
+//int ComlibGetLastKnown(CkArrayID aid, CkArrayIndex idx);
 
 
 #endif
index 75d87456dac786d4ee58a64525103691beb55a0b..822bd002ff83c7e046549299942b83f6aa2ee532 100644 (file)
@@ -41,9 +41,9 @@ EachToManyMulticastStrategy::EachToManyMulticastStrategy(int substrategy,
                CkArrayID src, 
                CkArrayID dest, 
                int nsrc, 
-               CkArrayIndexMax *srcelements, 
+               CkArrayIndex *srcelements, 
                int ndest, 
-               CkArrayIndexMax *destelements)
+               CkArrayIndex *destelements)
 : RouterStrategy(substrategy), CharmStrategy() {
        ComlibPrintf("[%d] EachToManyMulticast array constructor. nsrc=%d ndest=%d\n",CkMyPe(), nsrc, ndest);
 
index ffa0807939832d474a5a05b08a4a27fbc9f6697a..ff30a8cffa63a2e0eac835db329944fec291df31 100644 (file)
@@ -43,8 +43,8 @@ class EachToManyMulticastStrategy : public RouterStrategy, public CharmStrategy
     /// TODO: Fix this to allow for the same parameters as would be given to an array section creation(ranges of indices).
     EachToManyMulticastStrategy(int substrategy, CkArrayID src, 
                                 CkArrayID dest, int nsrc=0, 
-                                CkArrayIndexMax *srcelements=0, int ndest=0, 
-                                CkArrayIndexMax *destelements=0);
+                                CkArrayIndex *srcelements=0, int ndest=0, 
+                                CkArrayIndex *destelements=0);
     
     EachToManyMulticastStrategy(CkMigrateMessage *m) : RouterStrategy(m), CharmStrategy(m) {
       ComlibPrintf("[%d] EachToManyMulticast migration constructor\n",CkMyPe());
index 56a532cfa9f6fe78bcc953d09731c2f3a08476bf..9e4e53e87f2223c26ed9da6de0ff2872bccc5195 100644 (file)
 //     sid->ndestpes = npes;    
 // }
 
-// KDirectHashObject *KDirectMulticastStrategy::createHashObject(int nelements, CkArrayIndexMax *elements){
+// KDirectHashObject *KDirectMulticastStrategy::createHashObject(int nelements, CkArrayIndex *elements){
 
 //     KDirectHashObject *kobj = new KDirectHashObject;
 //     kobj->pelist = new int[kfactor];
 
 
 // void KDirectMulticastStrategy::getPeList(int nelements, 
-//                                          CkArrayIndexMax *elements, 
+//                                          CkArrayIndex *elements, 
 //                                          int *pelist, int &npes, 
 //                                          int src_pe){
     
index c44b8742f884e9a0008713d3da349cc1d3a7bd5b..005ab48faeaa59fe57550f1f12b2daefeceb8b29 100644 (file)
@@ -11,7 +11,7 @@
 
 /* class KDirectHashObject{ */
 /*  public: */
-/*     CkVec<CkArrayIndexMax> indices; */
+/*     CkVec<CkArrayIndex> indices; */
 /*     int npes; */
 /*     int *pelist; */
 /* }; */
index abe518913e8c618a3afc2194bd361ac69aefe49c..375f844e0480edaf4d19c70b007661c94636add1 100644 (file)
@@ -24,7 +24,7 @@ class short_envelope {
     UShort epIdx;
     UShort size;  //Can only send messages up to 64KB :)    
     
-    CkArrayIndexMax idx;
+    CkArrayIndex idx;
     char *data;
 
     short_envelope();
@@ -114,7 +114,7 @@ inline void MsgPacker::deliver(CombinedMessage *cmb_msg){
     CkArray *a=(CkArray *)_localBranch(aid);
 
     ArrayElement *a_elem=NULL, *prev_elem=NULL;
-    CkArrayIndexMax prev_idx;
+    CkArrayIndex prev_idx;
     prev_idx.nInts = -1;
 
     for(int count = 0; count < nmsgs; count ++){
index 43c851b128b4130190ceea557daef4c4185cf9a0..62a68fcd0764dffd41c1e088e1e2bae9d62f550a 100644 (file)
@@ -365,7 +365,7 @@ void MulticastStrategy::handleNewMulticastMessage(envelope *env) {
 
   int localElems;
   envelope *newenv;
-  CkArrayIndexMax *local_idx_list;    
+  CkArrayIndex *local_idx_list;    
     
   // Extract the list of elements to be delivered locally
   sinfo.unpack(env, localElems, local_idx_list, newenv);
@@ -382,7 +382,7 @@ void MulticastStrategy::handleNewMulticastMessage(envelope *env) {
   }
 
   /*
-    CkArrayIndexMax *idx_list_array = new CkArrayIndexMax[idx_list.size()];
+    CkArrayIndex *idx_list_array = new CkArrayIndex[idx_list.size()];
     for(int count = 0; count < idx_list.size(); count++)
     idx_list_array[count] = idx_list[count];
   */
index d60399000779adf2e54604b27aefcbde4dd5ed55..a25beda1e32815c842a4ddcda4638bea85fab39a 100644 (file)
@@ -33,7 +33,7 @@
 // //Handles multicast by sending only one message to a nodes and making 
 // //them multicast locally
 // void NodeMulticast::setDestinationArray(CkArrayID a, int nelem, 
-//                                     CkArrayIndexMax **idx, int ep){
+//                                     CkArrayIndex **idx, int ep){
 
 //     mode = ARRAY_MODE;
 //     messageBuf = NULL;
@@ -53,7 +53,7 @@
 //     ComlibPrintf("In SetDestinationArray %d, %d, %d, %d\n", numNodes, 
 //                  pes_per_node, nelements, ep);
   
-//     indexVec = new CkVec<CkArrayIndexMax> [CkNumPes()];
+//     indexVec = new CkVec<CkArrayIndex> [CkNumPes()];
     
 //     for(int count = 0; count < nelements; count++) {
 //         ComlibPrintf("Before lastKnown %d\n", count);
            
 //         ComlibPrintf("[%d], %d elements to send to %d of size %d\n", CkMyPe(), size, dest_pe, env->getTotalsize());
            
-//         CkArrayIndexMax * idx_arr = indexVec[dest_pe].getVec();
+//         CkArrayIndex * idx_arr = indexVec[dest_pe].getVec();
 //         for(int itr = 0; itr < size; itr ++) {
 //             void *newcharmmsg = CkCopyMsg(&charm_msg); 
 //             envelope* newenv = UsrToEnv(newcharmmsg);
 //         nodeMap = new int[numNodes];
        
 //     if(mode == ARRAY_MODE) {
-//         typedef CkVec<CkArrayIndexMax> CkVecArrayIndex;
+//         typedef CkVec<CkArrayIndex> CkVecArrayIndex;
 //         CkVecArrayIndex *vec = new CkVecArrayIndex[CkNumPes()];
 //         indexVec = vec;
 //     }
index 2240b2a82e8647fe47567e1ce1b935316716691f..b4591cfc54817134d53bb8d1f1049257614b28b8 100644 (file)
@@ -18,7 +18,7 @@
 /*     int mode; //Array destinations or processor destinations */
 
 /*     CkArrayID mAid; */
-/*     CkVec<CkArrayIndexMax> *indexVec; */
+/*     CkVec<CkArrayIndex> *indexVec; */
 /*     int NodeMulticastHandlerId, entryPoint, nelements; */
     
 /*     int npes, *pelist, NodeMulticastCallbackHandlerId; */
@@ -33,7 +33,7 @@
 /*  public: */
 /*     NodeMulticast(){} */
 /*     void setDestinationArray(CkArrayID a, int nelem,  */
-/*                          CkArrayIndexMax **idx, int ep); */
+/*                          CkArrayIndex **idx, int ep); */
 
 /*     //void setPeList(int npes, int *pelist, CkCallback callback); */
 /*     //void setPeList(int npes, int *pelist, ComlibMulticastHandler handler); */
index 0f7319a5967b25064dd5b2a796f3168cb9b79dd2..42f0e6afdde5a1faefb12c214f78a13d177b82dd 100644 (file)
@@ -86,7 +86,7 @@ void OneTimeMulticastStrategy::insertMessage(CharmMessageHolder *cmsg){
 void OneTimeMulticastStrategy::localMulticast(CharmMessageHolder *cmsg) {
   double start = CmiWallTimer();
   CkSectionID *sec_id = cmsg->sec_id;
-  CkVec< CkArrayIndexMax > localIndices;
+  CkVec< CkArrayIndex > localIndices;
   sinfo.getLocalIndices(sec_id->_nElems, sec_id->_elems, sec_id->_cookie.aid, localIndices);
   deliverToIndices(cmsg->getCharmMessage(), localIndices );
   traceUserBracketEvent(10000, start, CmiWallTimer());
@@ -196,7 +196,7 @@ void OneTimeMulticastStrategy::handleMessage(void *msg){
   // Deliver to objects marked as local in the message
   int localElems;
   envelope *newenv;
-  CkArrayIndexMax *local_idx_list;  
+  CkArrayIndex *local_idx_list;  
   sinfo.unpack(env, localElems, local_idx_list, newenv);
   ComlibMulticastMsg *newmsg = (ComlibMulticastMsg *)EnvToUsr(newenv);  
 
index 0b06a91ae611e8d91c72e1ca8f84177a8ed080db..33656ef6c70da69607ccd4fab1aecf96119a2bc2 100644 (file)
@@ -271,7 +271,7 @@ void RectMulticastStrategy::insertSectionID(CkSectionID *sid) {
 
 
 ComlibRectSectionHashObject *
-RectMulticastStrategy::createObjectOnSrcPe(int nindices, CkArrayIndexMax *idxlist, unsigned int thisSectionID) {
+RectMulticastStrategy::createObjectOnSrcPe(int nindices, CkArrayIndex *idxlist, unsigned int thisSectionID) {
 
     ComlibPrintf("[%d] createObjectOnSrcPe \n", CkMyPe());   
     ComlibPrintf("[%d] Rect createObjectOnSrcPe \n", CkMyPe());   
@@ -488,7 +488,7 @@ BGTsRC_Geometry_t *RectMulticastStrategy::getRectGeometry(ComlibRectSectionHashO
 
 ComlibRectSectionHashObject *
 RectMulticastStrategy::createObjectOnIntermediatePe(int nindices,
-                                                     CkArrayIndexMax *idxlist,
+                                                     CkArrayIndex *idxlist,
                                                      int npes,
                                                      ComlibMulticastIndexCount *counts,
                                                      int srcpe, int thisSectionID) {
@@ -677,7 +677,7 @@ void RectMulticastStrategy::beginProcessing(int numElements){
     bgl_machine_RectBcastConfigure (rectRequest);
     CkArrayID dest;
     int nidx;
-    CkArrayIndexMax *idx_list;
+    CkArrayIndex *idx_list;
 
     ainfo.getDestinationArray(dest, idx_list, nidx);
     sinfo = ComlibSectionInfo(dest, myInstanceID);
@@ -756,7 +756,7 @@ void RectMulticastStrategy::handleNewMulticastMessage(envelope *env) {
     int sender=env->getSrcPe();
     int localElems;
     envelope *newenv;
-    CkArrayIndexMax *local_idx_list;    
+    CkArrayIndex *local_idx_list;    
     
     sinfo.unpack(env, localElems, local_idx_list, newenv);
 
@@ -773,7 +773,7 @@ void RectMulticastStrategy::handleNewMulticastMessage(envelope *env) {
     }
 
     /*
-    CkArrayIndexMax *idx_list_array = new CkArrayIndexMax[idx_list.size()];
+    CkArrayIndex *idx_list_array = new CkArrayIndex[idx_list.size()];
     for(int count = 0; count < idx_list.size(); count++)
         idx_list_array[count] = idx_list[count];
     */
index d992454033d242fa7b7a8114771487aa66001cee..dbf62ff75fa5a98cfc61214b0595e12e3c235d69 100644 (file)
@@ -64,7 +64,7 @@ class RectMulticastStrategy: public Strategy, public CharmStrategy {
     ///Called when a new section multicast is called by the user locally.
     ///The strategy should then create a topology for it and return a hash
     ///object to store that topology.
-    virtual ComlibRectSectionHashObject *createObjectOnSrcPe(int nindices, CkArrayIndexMax *idx_list, unsigned int sectionid);
+    virtual ComlibRectSectionHashObject *createObjectOnSrcPe(int nindices, CkArrayIndex *idx_list, unsigned int sectionid);
 
     /**   
      * Similar to createHashObjectOnSrcPe, but that this call is made on the
@@ -79,7 +79,7 @@ class RectMulticastStrategy: public Strategy, public CharmStrategy {
      * @param srcpe processor which started the multicast
      * @return a hash object describing the section
      */
-    virtual ComlibRectSectionHashObject *createObjectOnIntermediatePe(int nindices, CkArrayIndexMax *idxlist, int npes, ComlibMulticastIndexCount *counts, int srcpe, int sectionID);
+    virtual ComlibRectSectionHashObject *createObjectOnIntermediatePe(int nindices, CkArrayIndex *idxlist, int npes, ComlibMulticastIndexCount *counts, int srcpe, int sectionID);
         
     ///Needed for getNewMulticastMessage, to specify if the list of processors need to be ordered
     virtual int needSorting() { return 0; }
index 53cdbb3ef39bd590440415cdb317c05602c5c08b..187775bb8e9706925f1a153e429698739d75aa3a 100644 (file)
@@ -644,8 +644,8 @@ class CkDelegateMgr : public IrrGroup {
     virtual void NodeGroupBroadcast(CkDelegateData *pd,int ep,void *m,CkNodeGroupID g);
     virtual void NodeGroupSectionSend(CkDelegateData *pd,int ep,void *m,int nsid,CkSectionID *s);
 
-    virtual void ArrayCreate(CkDelegateData *pd,int ep,void *m,const CkArrayIndexMax &idx,int onPE,CkArrayID a);
-    virtual void ArraySend(CkDelegateData *pd,int ep,void *m,const CkArrayIndexMax &idx,CkArrayID a);
+    virtual void ArrayCreate(CkDelegateData *pd,int ep,void *m,const CkArrayIndex &idx,int onPE,CkArrayID a);
+    virtual void ArraySend(CkDelegateData *pd,int ep,void *m,const CkArrayIndex &idx,CkArrayID a);
     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
     virtual void ArraySectionSend(CkDelegateData *pd,int ep,void *m,int nsid,CkSectionID *s,int opts);
     virtual void initDelegateMgr(CProxy *proxy)  {}
index a54c3639d2b7b2e5acd34e87da72b41786d75547..b813684fe5b2b12542e78683860916aab168c119 100644 (file)
@@ -253,12 +253,12 @@ void CkDelegateMgr::NodeGroupBroadcast(CkDelegateData *pd,int ep,void *m,CkNodeG
   { CkBroadcastMsgNodeBranch(ep,m,g); }
 void CkDelegateMgr::NodeGroupSectionSend(CkDelegateData *pd,int ep,void *m,int nsid,CkSectionID *s)
   { CkSendMsgNodeBranchMulti(ep,m,s->_cookie.aid,s->npes,s->pelist); }
-void CkDelegateMgr::ArrayCreate(CkDelegateData *pd,int ep,void *m,const CkArrayIndexMax &idx,int onPE,CkArrayID a)
+void CkDelegateMgr::ArrayCreate(CkDelegateData *pd,int ep,void *m,const CkArrayIndex &idx,int onPE,CkArrayID a)
 {
        CProxyElement_ArrayBase ap(a,idx);
        ap.ckInsert((CkArrayMessage *)m,ep,onPE);
 }
-void CkDelegateMgr::ArraySend(CkDelegateData *pd,int ep,void *m,const CkArrayIndexMax &idx,CkArrayID a)
+void CkDelegateMgr::ArraySend(CkDelegateData *pd,int ep,void *m,const CkArrayIndex &idx,CkArrayID a)
 {
        CProxyElement_ArrayBase ap(a,idx);
        ap.ckSend((CkArrayMessage *)m,ep);
@@ -356,7 +356,7 @@ void CProxy::pup(PUP::er &p) {
 CkSectionID::CkSectionID(const CkArrayID &aid, const CkArrayIndex##index *elems, const int nElems): _nElems(nElems) { \
   _cookie.aid = aid;   \
   _cookie.get_pe() = CkMyPe(); \
-  _elems = new CkArrayIndexMax[nElems];        \
+  _elems = new CkArrayIndex[nElems];   \
   for (int i=0; i<nElems; i++) _elems[i] = elems[i];   \
   pelist = NULL;       \
   npes  = 0;   \
@@ -381,7 +381,7 @@ CkSectionID::CkSectionID(const CkSectionID &sid) {
   _cookie = sid._cookie;
   _nElems = sid._nElems;
   if (_nElems > 0) {
-    _elems = new CkArrayIndexMax[_nElems];
+    _elems = new CkArrayIndex[_nElems];
     for (i=0; i<_nElems; i++) _elems[i] = sid._elems[i];
   } else _elems = NULL;
   npes = sid.npes;
@@ -396,7 +396,7 @@ void CkSectionID::operator=(const CkSectionID &sid) {
   _cookie = sid._cookie;
   _nElems = sid._nElems;
   if (_nElems > 0) {
-    _elems = new CkArrayIndexMax[_nElems];
+    _elems = new CkArrayIndex[_nElems];
     for (i=0; i<_nElems; i++) _elems[i] = sid._elems[i];
   } else _elems = NULL;
   npes = sid.npes;
@@ -410,7 +410,7 @@ void CkSectionID::pup(PUP::er &p) {
     p | _cookie;
     p(_nElems);
     if (_nElems > 0) {
-      if (p.isUnpacking()) _elems = new CkArrayIndexMax[_nElems];
+      if (p.isUnpacking()) _elems = new CkArrayIndex[_nElems];
       for (int i=0; i< _nElems; i++) p | _elems[i];
       npes = 0;
       pelist = NULL;
index d7e0db17dc124879afb3f955b4f10b096cede9a8..7131eeccf59d16dd41182466847d04892f1c69e6 100644 (file)
@@ -17,8 +17,8 @@ int getAvailMemory(int grainsize);
 
 int 
 IGetControlClass::IGetControlClass::iget_request(CkIGetID fut, void *msg,
-int ep, CkArrayID id, CkArrayIndexMax idx,
-void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int),int msgsize)
+int ep, CkArrayID id, CkArrayIndex idx,
+void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int),int msgsize)
  {
     if(msgsize>0)  IGET_UNITMESSAGE=msgsize;
     int ret_status=1, size=1;
index b2905fb5a922188c2c7d7621b06ae53d22927b64..79dd41d30d428491dcb07dc0d7e015687d479139 100644 (file)
@@ -32,7 +32,7 @@ extern "C" int getRSS();
 
 class IGetControlClass {
 public:
-  int iget_request(CkIGetID fut, void *msg, int ep, CkArrayID, CkArrayIndexMax, void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int))
+  int iget_request(CkIGetID fut, void *msg, int ep, CkArrayID, CkArrayIndex, void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int))
     {return 1;}
   void iget_free(CthThread tid, int size) {}
   void iget_resend(CkIGetID) {}
@@ -126,8 +126,8 @@ typedef struct iget_token_struct {
 //  void *obj;     
 //  void(*fptr1)(void*,void*,int,int);
   CkArrayID aid;
-  CkArrayIndexMax idx;
-  void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int);   
+  CkArrayIndex idx;
+  void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int);   
 } *iget_tokenqueue_entry;
 
 typedef HashQueueT<CkIGetID, iget_tokenqueue_entry> HashTokenQueue;
@@ -150,7 +150,7 @@ public:
   }
 */
        int iget_request(CkIGetID fut, void *msg, int ep, CkArrayID id,
-CkArrayIndexMax idx, void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int),
+CkArrayIndex idx, void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int),
 int);
 
        void iget_free(int size);
@@ -205,8 +205,8 @@ private:
     queue.key_enq(e,gid);
   } 
 */
-  inline void iget_tokenqueue_enqueue(CkIGetID gid,void* m,int ep, CkArrayID aid, CkArrayIndexMax
-                                     idx, void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int))
+  inline void iget_tokenqueue_enqueue(CkIGetID gid,void* m,int ep, CkArrayID aid, CkArrayIndex
+                                     idx, void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int))
   {
     iget_tokenqueue_entry e=new iget_token_struct();
     e->futNum=gid; e->m=m; e->ep=ep; e->aid=aid; e->idx=idx; e->fptr=fptr; e->status=0;
index d61949f46c88dd709e2d695ffe8639575dd8aed7..57522df14f0654bd1f88ad1e2949ae627bcaec26 100644 (file)
@@ -168,7 +168,7 @@ CProxyElement_ArrayBase::ckSendWrapper(void *me, void *m, int ep, int opts){
 }
 */
 void
-CProxyElement_ArrayBase::ckSendWrapper(CkArrayID _aid, CkArrayIndexMax _idx, void *m, int ep, int opts) {
+CProxyElement_ArrayBase::ckSendWrapper(CkArrayID _aid, CkArrayIndex _idx, void *m, int ep, int opts) {
        CProxyElement_ArrayBase me = CProxyElement_ArrayBase(_aid,_idx);
        ((CProxyElement_ArrayBase)me).ckSend((CkArrayMessage*)m,ep,opts);
 }
@@ -230,7 +230,7 @@ class ArrayElement_initInfo {
 public:
   CkArray *thisArray;
   CkArrayID thisArrayID;
-  CkArrayIndexMax numInitial;
+  CkArrayIndex numInitial;
   int listenerData[CK_ARRAYLISTENER_MAXLEN];
   CmiBool fromMigration;
 };
@@ -372,7 +372,7 @@ int ArrayElement::ckDebugChareID(char *str, int limit) {
   if (limit<21) return -1;
   str[0] = 2;
   *((int*)&str[1]) = ((CkGroupID)thisArrayID).idx;
-  *((CkArrayIndexMax*)&str[5]) = thisIndexMax;
+  *((CkArrayIndex*)&str[5]) = thisIndexMax;
   return 21;
 }
 
index 4fca43db6655da81863d2ae6e86f01ceea441cc7..a3dfe0c61d531e26d6faf91ba97eccf10dfb2378 100644 (file)
@@ -295,7 +295,7 @@ class CkVerboseListener : public CkArrayListener {
 class CkArrayOptions {
        friend class CkArray;
 
-       CkArrayIndexMax numInitial;///< Number of elements to create
+       CkArrayIndex numInitial;///< Number of elements to create
        CkGroupID map;///< Array location map object
        CkGroupID locMgr;///< Location manager to bind to
        CkPupAblePtrVec<CkArrayListener> arrayListeners; //CkArrayListeners for this array
@@ -363,7 +363,7 @@ class CkArrayOptions {
        { reductionClient = cb; return *this; }
 
   //Used by the array manager:
-       const CkArrayIndexMax &getNumInitial(void) const {return numInitial;}
+       const CkArrayIndex &getNumInitial(void) const {return numInitial;}
        const CkGroupID &getMap(void) const {return map;}
        const CkGroupID &getLocationManager(void) const {return locMgr;}
        int getListeners(void) const {return arrayListeners.size();}
@@ -433,7 +433,7 @@ PUPmarshall(CProxy_ArrayBase)
 
 class CProxyElement_ArrayBase:public CProxy_ArrayBase {
 private:
-       CkArrayIndexMax _idx;//<- our element's array index
+       CkArrayIndex _idx;//<- our element's array index
 public:
        CProxyElement_ArrayBase() { }
        CProxyElement_ArrayBase(const CkArrayID &aid,
@@ -446,7 +446,7 @@ public:
        void ckInsert(CkArrayMessage *m,int ctor,int onPe);
        void ckSend(CkArrayMessage *m, int ep, int opts = 0) const;
 //      static void ckSendWrapper(void *me, void *m, int ep, int opts = 0);
-      static void ckSendWrapper(CkArrayID _aid, CkArrayIndexMax _idx, void *m, int ep, int opts);
+      static void ckSendWrapper(CkArrayID _aid, CkArrayIndex _idx, void *m, int ep, int opts);
        void *ckSendSync(CkArrayMessage *m, int ep) const;
        const CkArrayIndex &ckGetIndex() const {return _idx;}
 
@@ -462,10 +462,10 @@ private:
 public:
        CProxySection_ArrayBase(): _nsid(0), _sid(NULL) {}
        CProxySection_ArrayBase(const CkArrayID &aid,
-               const CkArrayIndexMax *elems, const int nElems)
+               const CkArrayIndex *elems, const int nElems)
                :CProxy_ArrayBase(aid), _nsid(1) { _sid = new CkSectionID(aid, elems, nElems); }
        CProxySection_ArrayBase(const CkArrayID &aid,
-               const CkArrayIndexMax *elems, const int nElems, CK_DELCTOR_PARAM)
+               const CkArrayIndex *elems, const int nElems, CK_DELCTOR_PARAM)
                :CProxy_ArrayBase(aid,CK_DELCTOR_ARGS), _nsid(1) { _sid = new CkSectionID(aid, elems, nElems); }
        CProxySection_ArrayBase(const CkSectionID &sid)
                :CProxy_ArrayBase(sid._cookie.aid), _nsid(1) { _sid = new CkSectionID(sid); }
@@ -487,7 +487,7 @@ public:
         for (int i=0; i<_nsid; ++i) _sid[i] = cs._sid[i];
       } else _sid = NULL;
     }
-    CProxySection_ArrayBase(const int n, const CkArrayID *aid, CkArrayIndexMax const * const *elems, const int *nElems)
+    CProxySection_ArrayBase(const int n, const CkArrayID *aid, CkArrayIndex const * const *elems, const int *nElems)
         :CProxy_ArrayBase(aid[0]), _nsid(n) {
       if (_nsid == 1) _sid = new CkSectionID(aid[0], elems[0], nElems[0]);
       else if (_nsid > 1) {
@@ -495,7 +495,7 @@ public:
       for (int i=0; i<n; ++i) _sid[i] = CkSectionID(aid[i], elems[i], nElems[i]);
       } else _sid = NULL;
     }
-    CProxySection_ArrayBase(const int n, const CkArrayID *aid, CkArrayIndexMax const * const *elems, const int *nElems,CK_DELCTOR_PARAM)
+    CProxySection_ArrayBase(const int n, const CkArrayID *aid, CkArrayIndex const * const *elems, const int *nElems,CK_DELCTOR_PARAM)
         :CProxy_ArrayBase(aid[0],CK_DELCTOR_ARGS), _nsid(n) {
       if (_nsid == 1) _sid = new CkSectionID(aid[0], elems[0], nElems[0]);
       else if (_nsid > 1) {
@@ -532,8 +532,8 @@ public:
        inline CkSectionID &ckGetSectionID() {return _sid[0];}
        inline CkSectionID &ckGetSectionID(int i) {return _sid[i];}
        inline CkArrayID ckGetArrayIDn(int i) const {return _sid[i]._cookie.aid;}
-    inline CkArrayIndexMax *ckGetArrayElements() const {return _sid[0]._elems;}
-    inline CkArrayIndexMax *ckGetArrayElements(int i) const {return _sid[i]._elems;}
+    inline CkArrayIndex *ckGetArrayElements() const {return _sid[0]._elems;}
+    inline CkArrayIndex *ckGetArrayElements(int i) const {return _sid[i]._elems;}
     inline int ckGetNumElements() const { return _sid[0]._nElems; }
        inline int ckGetNumElements(int i) const { return _sid[i]._nElems; }
        void pup(PUP::er &p);
@@ -689,7 +689,7 @@ public:
 
 //Access & information routines
   inline CkLocMgr *getLocMgr(void) {return locMgr;}
-  inline const CkArrayIndexMax &getNumInitial(void) const {return numInitial;}
+  inline const CkArrayIndex &getNumInitial(void) const {return numInitial;}
   inline int homePe(const CkArrayIndex &idx) const {return locMgr->homePe(idx);}
   inline int procNum(const CkArrayIndex &idx) const {return locMgr->procNum(idx);}
 
@@ -742,7 +742,7 @@ public:
   virtual CmiBool isArrMgr(void) {return CmiTrue;}
 
 private:
-  CkArrayIndexMax numInitial;/// Number of initial array elements
+  CkArrayIndex numInitial;/// Number of initial array elements
   CmiBool isInserting;/// Are we currently inserting elements?
 
 /// Allocate space for a new array element
index bb50f5c41173419e90d37a864eca21d64215ae1d..fbfb930a4a0384356c6c6d382350642a084908c7 100644 (file)
@@ -25,7 +25,7 @@
 
 extern const char *idx2str(const CkArrayIndex &ind);
 extern const char *idx2str(const ArrayElement *el);
-const char *idx2str(const CkArrayIndexMax &ind){
+const char *idx2str(const CkArrayIndex &ind){
        return idx2str((const CkArrayIndex &)ind);
 };
 
@@ -1549,7 +1549,7 @@ private:
 public:
                ElementPacker(CkLocMgr* mgr_, PUP::er &p_):locMgr(mgr_),p(p_){};
                void addLocation(CkLocation &loc) {
-                       CkArrayIndexMax idx=loc.getIndex();
+                       CkArrayIndex idx=loc.getIndex();
                        CkGroupID gID = locMgr->ckGetGroupID();
                        p|gID;      // store loc mgr's GID as well for easier restore
                        p|idx;
@@ -1584,7 +1584,7 @@ void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSki
        
                for (int i=0; i<numElements; i++) {
                        CkGroupID gID;
-                       CkArrayIndexMax idx;
+                       CkArrayIndex idx;
                        p|gID;
                p|idx;
                        int flag=0;
@@ -2436,7 +2436,7 @@ void updateHomePE(void *data,ChareMlogData *mlogData){
        if(mlogData->objID.type == TypeArray){
                //it is an array element
                CkGroupID myGID = mlogData->objID.data.array.id;
-               CkArrayIndexMax myIdx =  mlogData->objID.data.array.idx;
+               CkArrayIndex myIdx =  mlogData->objID.data.array.idx;
                CkArrayID aid(mlogData->objID.data.array.id);           
                //check if the restarted processor is the home processor for this object
                CkLocMgr *locMgr = aid.ckLocalBranch()->getLocMgr();
@@ -2970,7 +2970,7 @@ class ElementDistributor: public CkLocIterator{
        CkLocMgr *locMgr;
        int *targetPE;
        void pupLocation(CkLocation &loc,PUP::er &p){
-               CkArrayIndexMax idx=loc.getIndex();
+               CkArrayIndex idx=loc.getIndex();
                CkGroupID gID = locMgr->ckGetGroupID();
                p|gID;      // store loc mgr's GID as well for easier restore
                p|idx;
@@ -2984,7 +2984,7 @@ class ElementDistributor: public CkLocIterator{
                                return;
                        }
                        
-                       CkArrayIndexMax idx=loc.getIndex();
+                       CkArrayIndex idx=loc.getIndex();
                        CkLocRec_local *rec = loc.getLocalRecord();
                        
                        CkPrintf("[%d] Distributing objects to Processor %d: ",CkMyPe(),*targetPE);
@@ -3031,7 +3031,7 @@ void _distributedLocationHandler(char *receivedMsg){
        char *buf = &receivedMsg[CmiMsgHeaderSizeBytes];
        PUP::fromMem pmem(buf);
        CkGroupID gID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        pmem |gID;
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
@@ -3060,7 +3060,7 @@ void _distributedLocationHandler(char *receivedMsg){
 
 /** this method is used to send messages to a restarted processor to tell
  * it that a particular expected object is not going to get to it */
-void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndexMax &idx,int locationPE){
+void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndex &idx,int locationPE){
        DummyMigrationMsg buf;
        buf.flag = MLOG_OBJECT;
        buf.lbID = lbID;
@@ -3348,7 +3348,7 @@ void _checkpointBarrierAckHandler(CheckpointBarrierMsg *msg){
        It is a converse method to bypass the charm++ message logging framework
 */
 
-void informLocationHome(CkGroupID locMgrID,CkArrayIndexMax idx,int homePE,int currentPE){
+void informLocationHome(CkGroupID locMgrID,CkArrayIndex idx,int homePE,int currentPE){
        double _startTime = CmiWallTimer();
        CurrentLocationMsg msg;
        msg.mgrID = locMgrID;
@@ -3522,7 +3522,7 @@ char *CkObjID::toString(char *buf) const {
                        break;
                case TypeArray:
                        {
-                               const CkArrayIndexMax &idx = data.array.idx;
+                               const CkArrayIndex &idx = data.array.idx;
                                const int *indexData = idx.data();
                                sprintf(buf,"Array |%d %d %d| id %d \0",indexData[0],indexData[1],indexData[2],data.array.id.idx);
                                break;
index 5a55ff1b72a14819f077c02a79dfe091ea05f7b0..4c44bbe6cccb4a6a9ba3a31065fecf8d804d07aa 100644 (file)
@@ -256,7 +256,7 @@ public:
  */
 class LocationID{
 public:
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        CkGroupID gid;
 };
 
@@ -404,7 +404,7 @@ typedef struct{
 
 typedef struct {
        CkGroupID gID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int fromPE,toPE;
        char ackFrom,ackTo;
 } MigrationRecord;
@@ -445,7 +445,7 @@ typedef struct {
 typedef struct {
        char header[CmiMsgHeaderSizeBytes];
        CkGroupID mgrID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int locationPE;
        int fromPE;
 } CurrentLocationMsg;
@@ -468,7 +468,7 @@ typedef struct {
        int count;// if just count
        /**if object **/
        CkGroupID mgrID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int locationPE;
 } DummyMigrationMsg;
 
@@ -559,7 +559,7 @@ void processReceivedTN(Chare *obj,int vecsize,MCount *listTNs);
 void initializeRestart(void *data,ChareMlogData *mlogData);
 void distributeRestartedObjects();
 void sortRestoredLocalMsgLog(void *_dummy,ChareMlogData *mlogData);
-void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndexMax &idx,int locationPE);
+void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndex &idx,int locationPE);
 
 //TML: function for locally calling the restart
 void CkMlogRestartLocal();
@@ -640,7 +640,7 @@ extern void _initDone(void);
 extern void _resetNodeBocInitVec(void);
 
 //methods for updating location
-void informLocationHome(CkGroupID mgrID,CkArrayIndexMax idx,int homePE,int currentPE);
+void informLocationHome(CkGroupID mgrID,CkArrayIndex idx,int homePE,int currentPE);
 
 //handlers for updating locations
 void _receiveLocationHandler(CurrentLocationMsg *data);
index 2b8888ee3fb97c5c67d95ae1e9413e91cb9baa65..1448521687ef22fb1d787e1d2665991b724d8fc6 100644 (file)
@@ -54,7 +54,7 @@ private:
 public:
         ElementCheckpointer(CkLocMgr* mgr_, PUP::er &p_):locMgr(mgr_),p(p_){};
         void addLocation(CkLocation &loc) {
-                CkArrayIndexMax idx=loc.getIndex();
+                CkArrayIndex idx=loc.getIndex();
                CkGroupID gID = locMgr->ckGetGroupID();
                p|gID;      // store loc mgr's GID as well for easier restore
                 p|idx;
@@ -522,7 +522,7 @@ void CkPupArrayElementsData(PUP::er &p, int notifyListeners)
          //CkPrintf("total chare array cnts: %d\n", numElements);
          for (int i=0; i<numElements; i++) {
                CkGroupID gID;
-               CkArrayIndexMax idx;
+               CkArrayIndex idx;
                p|gID;
                 p|idx;
                CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
index 2113ebb436ad69299a0844fb108ba96516964bd6..93ac30ff5141a1e66a161da1f1b05799d84ff83d 100644 (file)
@@ -328,8 +328,8 @@ extern "C" CkFutureID CkCreateAttachedFuture(void *msg)
 }
 
 extern "C" CkFutureID CkCreateAttachedFutureSend(void *msg, int ep,
-CkArrayID id, CkArrayIndexMax idx,
-void(*fptr)(CkArrayID,CkArrayIndexMax,void*,int,int),int size)
+CkArrayID id, CkArrayIndex idx,
+void(*fptr)(CkArrayID,CkArrayIndex,void*,int,int),int size)
 {
 CkFutureID ret=createFuture();
 UsrToEnv(msg)->setRef(ret);
index 2c2a7ea45fc061743e855f6473915cffae001ab6..79da94f4310b1aeec104638999ec52729a087c98 100644 (file)
@@ -86,7 +86,7 @@ LDObjid idx2LDObjid(const CkArrayIndex &idx)
 #endif
 
 /*********************** Array Messages ************************/
-CkArrayIndexMax &CkArrayMessage::array_index(void)
+CkArrayIndex &CkArrayMessage::array_index(void)
 {
     return UsrToEnv((void *)this)->getsetArrayIndex();
 }
@@ -124,7 +124,7 @@ be forwarded by default.
 
 CkArrayMap::CkArrayMap(void) { }
 CkArrayMap::~CkArrayMap() { }
-int CkArrayMap::registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
+int CkArrayMap::registerArray(CkArrayIndex& numElements,CkArrayID aid)
 {return 0;}
 
 #define CKARRAYMAP_POPULATE_INITIAL(POPULATE_CONDITION) \
@@ -160,14 +160,14 @@ int CkArrayMap::registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
           } \
        }
 
-void CkArrayMap::populateInitial(int arrayHdl,CkArrayIndexMax& numElements,void *ctorMsg,CkArrMgr *mgr)
+void CkArrayMap::populateInitial(int arrayHdl,CkArrayIndex& numElements,void *ctorMsg,CkArrMgr *mgr)
 {
        if (numElements.nInts==0) {
           CkFreeMsg(ctorMsg);
           return;
         }
        int thisPe=CkMyPe();
-        /* The CkArrayIndexMax is supposed to have at most 3 dimensions, which
+        /* The CkArrayIndex is supposed to have at most 3 dimensions, which
            means that all the fields are ints, and numElements.nInts represents
            how many of them are used */
         CKARRAYMAP_POPULATE_INITIAL(procNum(arrayHdl,idx)==thisPe);
@@ -223,7 +223,7 @@ public:
  */
 class arrayMapInfo {
 public:
-  CkArrayIndexMax _nelems;
+  CkArrayIndex _nelems;
   int _binSizeFloor;           /* floor of numChares/numPes */
   int _binSizeCeil;            /* ceiling of numChares/numPes */
   int _numChares;              /* initial total number of chares */
@@ -237,7 +237,7 @@ public:
 
   arrayMapInfo(void) { }
 
-  arrayMapInfo(CkArrayIndexMax& n) : _nelems(n), _numChares(0) {
+  arrayMapInfo(CkArrayIndex& n) : _nelems(n), _numChares(0) {
     compute_binsize();
   }
 
@@ -290,7 +290,7 @@ public:
 
   DefaultArrayMap(CkMigrateMessage *m) : RRMap(m){}
 
-  int registerArray(CkArrayIndexMax& numElements, CkArrayID aid)
+  int registerArray(CkArrayIndex& numElements, CkArrayID aid)
   {
     int idx = amaps.size();
     amaps.resize(idx+1);
@@ -350,7 +350,7 @@ public:
 
   FastArrayMap(CkMigrateMessage *m) : DefaultArrayMap(m){}
 
-  int registerArray(CkArrayIndexMax& numElements, CkArrayID aid)
+  int registerArray(CkArrayIndex& numElements, CkArrayID aid)
   {
     int idx;
     idx = DefaultArrayMap::registerArray(numElements, aid);
@@ -404,7 +404,7 @@ public:
 
   ReadFileMap(CkMigrateMessage *m) : DefaultArrayMap(m){}
 
-  int registerArray(CkArrayIndexMax& numElements, CkArrayID aid)
+  int registerArray(CkArrayIndex& numElements, CkArrayID aid)
   {
     int idx;
     idx = DefaultArrayMap::registerArray(numElements, aid);
@@ -466,7 +466,7 @@ public:
        DEBC((AA"Creating BlockMap\n"AB));
   }
   BlockMap(CkMigrateMessage *m):RRMap(m){ }
-  void populateInitial(int arrayHdl,CkArrayIndexMax& numElements,void *ctorMsg,CkArrMgr *mgr){
+  void populateInitial(int arrayHdl,CkArrayIndex& numElements,void *ctorMsg,CkArrMgr *mgr){
        if (numElements.nInts==0) {
           CkFreeMsg(ctorMsg);
           return;
@@ -486,7 +486,7 @@ public:
         CKARRAYMAP_POPULATE_INITIAL(i/binSize==thisPe);
 
         /*
-        CkArrayIndexMax idx;
+        CkArrayIndex idx;
        for (idx=numElements.begin(); idx<numElements; idx.getNext(numElements)) {
           //for (int i=0;i<numElements;i++) {
                int binSize = (int)ceil((double)numElements.getCombinedCount()/(double)numPes);
@@ -526,14 +526,14 @@ public:
   {
      return CLD_ANYWHERE;   // -1
   }
-  void populateInitial(int arrayHdl,CkArrayIndexMax& numElements,void *ctorMsg,CkArrMgr *mgr)  {
+  void populateInitial(int arrayHdl,CkArrayIndex& numElements,void *ctorMsg,CkArrMgr *mgr)  {
         if (numElements.nInts==0) {
           CkFreeMsg(ctorMsg);
           return;
         }
         int thisPe=CkMyPe();
         int numPes=CkNumPes();
-        //CkArrayIndexMax idx;
+        //CkArrayIndex idx;
 
         CKARRAYMAP_POPULATE_INITIAL(i%numPes==thisPe);
        /*for (idx=numElements.begin(); idx<numElements; idx.getNext(numElements)) {
@@ -643,7 +643,7 @@ public:
   ConfigurableRRMap(CkMigrateMessage *m):RRMap(m){ }
 
 
-  void populateInitial(int arrayHdl,CkArrayIndexMax& numElements,void *ctorMsg,CkArrMgr *mgr){
+  void populateInitial(int arrayHdl,CkArrayIndex& numElements,void *ctorMsg,CkArrMgr *mgr){
     // Try to load the configuration from command line argument
     CkAssert(haveConfigurableRRMap());
     ConfigurableRRMapLoader &loader =  CkpvAccess(myConfigRRMapState);
@@ -685,12 +685,12 @@ CkpvStaticDeclare(double*, rem);
 
 class arrInfo {
  private:
-   CkArrayIndexMax _nelems;
+   CkArrayIndex _nelems;
    int *_map;
    void distrib(int *speeds);
  public:
    arrInfo(void):_map(NULL){}
-   arrInfo(CkArrayIndexMax& n, int *speeds)
+   arrInfo(CkArrayIndex& n, int *speeds)
    {
      _nelems = n;
      _map = new int[_nelems.getCombinedCount()];
@@ -832,7 +832,7 @@ public:
     DEBC((AA"Creating PropMap\n"AB));
   }
   PropMap(CkMigrateMessage *m) {}
-  int registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
+  int registerArray(CkArrayIndex& numElements,CkArrayID aid)
   {
     int idx = arrs.size();
     arrs.resize(idx+1);
@@ -1765,7 +1765,7 @@ inline void CkLocMgr::springCleaning(void)
     if (rec->isObsolete(nSprings,idx)) {
       //This record is obsolete-- remove it from the table
       DEBK((AA"Cleaning out old record %s\n"AB,idx2str(idx)));
-      hash.remove(*(CkArrayIndexMax *)&idx);
+      hash.remove(*(CkArrayIndex *)&idx);
       delete rec;
       it->seek(-1);//retry this hash slot
     }
@@ -1794,7 +1794,7 @@ void CkLocMgr::flushAllRecs(void)
       //the meta data in the location manager are not deleted so we need
       //this condition
       if(_BgOutOfCoreFlag!=1){
-        hash.remove(*(CkArrayIndexMax *)&idx);
+        hash.remove(*(CkArrayIndex *)&idx);
         delete rec;
         it->seek(-1);//retry this hash slot
       }
@@ -1823,7 +1823,7 @@ void CkLocMgr::callForAllRecords(CkLocFn fnPointer,CkArray *arr,void *data){
 #endif
 
 /*************************** LocMgr: CREATION *****************************/
-CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkArrayIndexMax& numInitial)
+CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkArrayIndex& numInitial)
        :thisProxy(thisgroup),thislocalproxy(thisgroup,CkMyPe()),
         hash(17,0.3)
 {
@@ -1877,7 +1877,7 @@ void CkLocMgr::pup(PUP::er &p){
                //Register with the map object
                map=(CkArrayMap *)CkLocalBranch(mapID);
                if (map==NULL) CkAbort("ERROR!  Local branch of array map is NULL!");
-                CkArrayIndexMax emptyIndex;
+                CkArrayIndex emptyIndex;
                map->registerArray(emptyIndex,thisgroup);
                // _lbdb is the fixed global groupID
                initLB(lbdbID);
@@ -1889,7 +1889,7 @@ void CkLocMgr::pup(PUP::er &p){
         homeElementCount = count;
 
         for(int i=0;i<count;i++){
-            CkArrayIndexMax idx;
+            CkArrayIndex idx;
             int pe;
             idx.pup(p);
             p | pe;
@@ -1932,7 +1932,7 @@ void CkLocMgr::pup(PUP::er &p){
       while (NULL!=(objp=it->next(&keyp))) {
       CkLocRec *rec=*(CkLocRec **)objp;
         CkArrayIndex &idx=*(CkArrayIndex *)keyp;
-            CkArrayIndexMax max = idx;
+            CkArrayIndex max = idx;
             if(rec->type() != CkLocRec::local){
                 if(homePe(idx) == CmiMyPe()){
                     int pe;
@@ -2105,7 +2105,7 @@ CmiBool CkLocMgr::addElementToRec(CkLocRec_local *rec,ManagerRec *m,
        
        return CmiTrue;
 }
-void CkLocMgr::updateLocation(const CkArrayIndexMax &idx,int nowOnPe) {
+void CkLocMgr::updateLocation(const CkArrayIndex &idx,int nowOnPe) {
        inform(idx,nowOnPe);
 }
 
@@ -2150,7 +2150,7 @@ void CkLocMgr::reclaim(const CkArrayIndex &idx,int localIdx) {
        }
 }
 
-void CkLocMgr::reclaimRemote(const CkArrayIndexMax &idx,int deletedOnPe) {
+void CkLocMgr::reclaimRemote(const CkArrayIndex &idx,int deletedOnPe) {
        DEBC((AA"Our element %s died on PE %d\n"AB,idx2str(idx),deletedOnPe));
        CkLocRec *rec=elementNrec(idx);
        if (rec==NULL) return; //We never knew him
@@ -2165,7 +2165,7 @@ void CkLocMgr::removeFromTable(const CkArrayIndex &idx) {
                CkAbort("CkLocMgr::removeFromTable called on invalid index!");
 #endif
         CmiImmediateLock(hashImmLock);
-       hash.remove(*(CkArrayIndexMax *)&idx);
+       hash.remove(*(CkArrayIndex *)&idx);
         CmiImmediateUnlock(hashImmLock);
 #if CMK_ERROR_CHECKING
        //Make sure it's really gone
@@ -2555,7 +2555,7 @@ void CkLocMgr::emigrate(CkLocRec_local *rec,int toPe)
                return;
        }
 
-       CkArrayIndexMax idx=rec->getIndex();
+       CkArrayIndex idx=rec->getIndex();
 
 #if CMK_OUT_OF_CORE
        int localIdx=rec->getLocalIndex();
@@ -2848,7 +2848,7 @@ void CkLocMgr::insertRec(CkLocRec *rec,const CkArrayIndex &idx) {
 void CkLocMgr::insertRecN(CkLocRec *rec,const CkArrayIndex &idx) {
        DEBC((AA"  adding new rec(%s) for %s\n"AB,rec2str[rec->type()],idx2str(idx)));
         CmiImmediateLock(hashImmLock);
-       hash.put(*(CkArrayIndexMax *)&idx)=rec;
+       hash.put(*(CkArrayIndex *)&idx)=rec;
         CmiImmediateUnlock(hashImmLock);
 }
 
@@ -2863,7 +2863,7 @@ static void abort_out_of_bounds(const CkArrayIndex &idx)
 CkLocRec *CkLocMgr::elementRec(const CkArrayIndex &idx) {
 #if ! CMK_ERROR_CHECKING
 //Assume the element will be found
-       return hash.getRef(*(CkArrayIndexMax *)&idx);
+       return hash.getRef(*(CkArrayIndex *)&idx);
 #else
 //Include an out-of-bounds check if the element isn't found
        CkLocRec *rec=elementNrec(idx);
@@ -2874,7 +2874,7 @@ CkLocRec *CkLocMgr::elementRec(const CkArrayIndex &idx) {
 
 //Look up array element in hash table.  Return NULL if not there.
 CkLocRec *CkLocMgr::elementNrec(const CkArrayIndex &idx) {
-       return hash.get(*(CkArrayIndexMax *)&idx);
+       return hash.get(*(CkArrayIndex *)&idx);
 }
 
 struct LocalElementCounter :  public CkLocIterator
index c78bec8e5af09feb141a86753fa53d2bea649ce1..3a2271ee2d6e393c10f081eb9231e1250462b220 100644 (file)
@@ -6,11 +6,11 @@ module CkLocation {
   };
 
   group [migratable] CkLocMgr {
-       entry CkLocMgr(CkGroupID map,CkGroupID _lbdb,CkArrayIndexMax numInitial);
+       entry CkLocMgr(CkGroupID map,CkGroupID _lbdb,CkArrayIndex numInitial);
        entry void deliverInline(CkMessage *m);
        entry [expedited] void immigrate(CkArrayElementMigrateMessage *msg);
-       entry [expedited] void updateLocation(CkArrayIndexMax idx,int nowOnPe);
-       entry void reclaimRemote(CkArrayIndexMax idx,int deletedOnPe);
+       entry [expedited] void updateLocation(CkArrayIndex idx,int nowOnPe);
+       entry void reclaimRemote(CkArrayIndex idx,int deletedOnPe);
        
        //Load balancing:
        entry void dummyAtSync(void);
index c817b5f612e2e093e862962734526c994b9fe888..fd67729b1060018dcfc05726e9618fc0ee7cf476 100644 (file)
@@ -13,7 +13,7 @@ array proxies, or the details of element creation (see ckarray.h).
 class CkArrayMessage : public CkMessage {
 public:
   //These routines are implementation utilities
-  CkArrayIndexMax &array_index(void);
+  CkArrayIndex &array_index(void);
   unsigned short &array_ep(void);
   unsigned short &array_ep_bcast(void);
   unsigned char &array_hops(void);
@@ -57,7 +57,7 @@ typedef enum {
 
 class CkArrayElementMigrateMessage : public CMessage_CkArrayElementMigrateMessage {
 public:
-       CkArrayIndexMax idx; // Array index that is migrating
+       CkArrayIndex idx; // Array index that is migrating
        int ignoreArrival;   // if to inform LB of arrival
        int length;//Size in bytes of the packed data
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
@@ -88,8 +88,8 @@ public:
   CkArrayMap(void);
   CkArrayMap(CkMigrateMessage *m): IrrGroup(m) {}
   virtual ~CkArrayMap();
-  virtual int registerArray(CkArrayIndexMax& numElements,CkArrayID aid);
-  virtual void populateInitial(int arrayHdl,CkArrayIndexMax& numElements,void *ctorMsg,CkArrMgr *mgr);
+  virtual int registerArray(CkArrayIndex& numElements,CkArrayID aid);
+  virtual void populateInitial(int arrayHdl,CkArrayIndex& numElements,void *ctorMsg,CkArrMgr *mgr);
   virtual int procNum(int arrayHdl,const CkArrayIndex &element) =0;
   virtual int homePe(int arrayHdl,const CkArrayIndex &element)
              { return procNum(arrayHdl, element); }
@@ -163,7 +163,7 @@ public:
  * Represents a local array element.
  */
 class CkLocRec_local : public CkLocRec {
-  CkArrayIndexMax idx;/// Element's array index
+  CkArrayIndex idx;/// Element's array index
   int localIdx; /// Local index (into array manager's element lists)
   CmiBool running; /// True when inside a startTiming/stopTiming pair
   CmiBool *deletedMarker; /// Set this if we're deleted during processing
@@ -272,7 +272,7 @@ private:
   void commonInit(void);
   CmiBool asyncEvacuate;
 public:
-  CkArrayIndexMax thisIndexMax;
+  CkArrayIndex thisIndexMax;
 
   CkMigratable(void);
   CkMigratable(CkMigrateMessage *m);
@@ -519,7 +519,7 @@ typedef void (*CkLocFn)(CkArray *,void *,CkLocRec *,CkArrayIndex *);
 class CkLocMgr : public IrrGroup {
        CkMagicNumber<CkMigratable> magic; //To detect heap corruption
 public:
-       CkLocMgr(CkGroupID map,CkGroupID _lbdb,CkArrayIndexMax& numInitial);
+       CkLocMgr(CkGroupID map,CkGroupID _lbdb,CkArrayIndex& numInitial);
        CkLocMgr(CkMigrateMessage *m);
        inline CmiBool isLocMgr(void) { return CmiTrue; }
        CkGroupID &getGroupID(void) {return thisgroup;}
@@ -535,7 +535,7 @@ public:
        CkMigratableList *addManager(CkArrayID aid,CkArrMgr *mgr);
 
        /// Populate this array with initial elements
-       void populateInitial(CkArrayIndexMax& numElements,void *initMsg,CkArrMgr *mgr)
+       void populateInitial(CkArrayIndex& numElements,void *initMsg,CkArrMgr *mgr)
                {map->populateInitial(mapHandle,numElements,initMsg,mgr);}
 
        /// Add a new local array element, calling element's constructor
@@ -630,8 +630,8 @@ public:
 
 //Communication:
        void immigrate(CkArrayElementMigrateMessage *msg);
-       void updateLocation(const CkArrayIndexMax &idx,int nowOnPe);
-       void reclaimRemote(const CkArrayIndexMax &idx,int deletedOnPe);
+       void updateLocation(const CkArrayIndex &idx,int nowOnPe);
+       void reclaimRemote(const CkArrayIndex &idx,int deletedOnPe);
        void dummyAtSync(void);
 
        /// return a list of migratables in this local record
@@ -716,7 +716,7 @@ CkLocRec_local *createLocal(const CkArrayIndex &idx,
        CProxy_CkLocMgr thisProxy;
        CProxyElement_CkLocMgr thislocalproxy;
        /// The core of the location manager: map array index to element representative
-       CkHashtableT<CkArrayIndexMax,CkLocRec *> hash;
+       CkHashtableT<CkArrayIndex,CkLocRec *> hash;
        CmiImmediateLockType hashImmLock;
 
        /// This flag is set while we delete an old copy of a migrator
index 8dfdf1e14f40aefdfadb1d461ce909b9533cc072..09d8b02e7f3d729939d87ea3134bd30e1b616dcd 100644 (file)
@@ -175,7 +175,7 @@ class CkMemCheckPTInfo: public CkCheckPTInfo
 {
   CkArrayCheckPTMessage *ckBuffer;
 public:
-  CkMemCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndexMax idx, int pno): 
+  CkMemCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndex idx, int pno): 
                    CkCheckPTInfo(a, loc, idx, pno)
   {
     ckBuffer = NULL;
@@ -217,7 +217,7 @@ class CkDiskCheckPTInfo: public CkCheckPTInfo
   int bud1, bud2;
   int len;                     // checkpoint size
 public:
-  CkDiskCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndexMax idx, int pno, int myidx): CkCheckPTInfo(a, loc, idx, pno)
+  CkDiskCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndex idx, int pno, int myidx): CkCheckPTInfo(a, loc, idx, pno)
   {
 #if CMK_USE_MKSTEMP
     fname = new char[64];
@@ -376,7 +376,7 @@ int CkMemCheckPT::totalFailed()
 }
 
 // create an checkpoint entry for array element of aid with index.
-void CkMemCheckPT::createEntry(CkArrayID aid, CkGroupID loc, CkArrayIndexMax index, int buddy)
+void CkMemCheckPT::createEntry(CkArrayID aid, CkGroupID loc, CkArrayIndex index, int buddy)
 {
   // error check, no duplicate
   int idx, len = ckTable.size();
@@ -626,7 +626,7 @@ private:
 public:
         ElementDestoryer(CkLocMgr* mgr_):locMgr(mgr_){};
         void addLocation(CkLocation &loc) {
-               CkArrayIndexMax idx=loc.getIndex();
+               CkArrayIndex idx=loc.getIndex();
                CkPrintf("[%d] destroy: ", CkMyPe()); idx.print();
                loc.destroy();
         }
@@ -816,7 +816,7 @@ void CkMemCheckPT::gotData()
   }
 }
 
-void CkMemCheckPT::updateLocations(int n, CkGroupID *g, CkArrayIndexMax *idx,int nowOnPe)
+void CkMemCheckPT::updateLocations(int n, CkGroupID *g, CkArrayIndex *idx,int nowOnPe)
 {
   for (int i=0; i<n; i++) {
     CkLocMgr *mgr = CProxy_CkLocMgr(g[i]).ckLocalBranch();
@@ -839,7 +839,7 @@ void CkMemCheckPT::recoverArrayElements()
   int count = 0;
 #if STREAMING_INFORMHOME
   CkVec<CkGroupID> * gmap = new CkVec<CkGroupID>[CkNumPes()];
-  CkVec<CkArrayIndexMax> * imap = new CkVec<CkArrayIndexMax>[CkNumPes()];
+  CkVec<CkArrayIndex> * imap = new CkVec<CkArrayIndex>[CkNumPes()];
 #endif
   for (int idx=0; idx<len; idx++)
   {
index 672e00ca7d2ed41b11ec14ea4983f15b2f0ae1ec..a07e72db2e3f0d56df5317c5ea7cf122e6bfe049 100644 (file)
@@ -14,7 +14,7 @@ module CkMemCheckpoint {
 
   group [migratable] CkMemCheckPT {
         entry CkMemCheckPT(int w);
-       entry void createEntry(CkArrayID, CkGroupID, CkArrayIndexMax, int);
+       entry void createEntry(CkArrayID, CkGroupID, CkArrayIndex, int);
        // checkpointing
         entry [expedited] void doItNow(int spe, CkCallback &);  //checkpointing
        entry void recvData(CkArrayCheckPTMessage *);
@@ -33,7 +33,7 @@ module CkMemCheckpoint {
        entry void finishUp();
        entry void quiescence(CkCallback&);
         entry void inmem_restore(CkArrayCheckPTMessage *m);
-       entry void updateLocations(int n, CkGroupID g[n], CkArrayIndexMax idx[n],int nowOnPe);
+       entry void updateLocations(int n, CkGroupID g[n], CkArrayIndex idx[n],int nowOnPe);
   };
 
   initproc void CkRegisterRestartHandler();
index 8b4d42b51efc716ba3d320ea5939618ec24d8ad4..47029fe96b9e1ea30d61ab11d0df71792fcfa5da 100644 (file)
@@ -14,7 +14,7 @@ class CkArrayCheckPTMessage: public CMessage_CkArrayCheckPTMessage {
 public:
        CkArrayID  aid;
        CkGroupID  locMgr;
-       CkArrayIndexMax index;
+       CkArrayIndex index;
        double *packData;
        int bud1, bud2;
        int len;
@@ -37,11 +37,11 @@ class CkCheckPTInfo {
 protected:
    CkArrayID aid;
    CkGroupID locMgr;
-   CkArrayIndexMax index;
+   CkArrayIndex index;
    int pNo;   //another buddy
 public:
    CkCheckPTInfo();
-   CkCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndexMax idx, int pno):
+   CkCheckPTInfo(CkArrayID a, CkGroupID loc, CkArrayIndex idx, int pno):
                   aid(a), locMgr(loc), index(idx), pNo(pno)   {}
    virtual ~CkCheckPTInfo() {}
    virtual void updateBuffer(CkArrayCheckPTMessage *data) = 0;
@@ -64,7 +64,7 @@ public:
   void doItNow(int sp, CkCallback &);
   void restart(int diePe);
   void removeArrayElements();
-  void createEntry(CkArrayID aid, CkGroupID loc, CkArrayIndexMax index, int buddy);
+  void createEntry(CkArrayID aid, CkGroupID loc, CkArrayIndex index, int buddy);
   void recvData(CkArrayCheckPTMessage *);
   void gotData();
   void recvProcData(CkProcCheckPTMessage *);
@@ -78,7 +78,7 @@ public:
   void resetReductionMgr();
   void finishUp();
   void inmem_restore(CkArrayCheckPTMessage *m);
-  void updateLocations(int n, CkGroupID *g, CkArrayIndexMax *idx,int nowOnPe);
+  void updateLocations(int n, CkGroupID *g, CkArrayIndex *idx,int nowOnPe);
   void resetLB(int diepe);
 public:
   static CkCallback  cpCallback;
index dc4bd7856c344efbc5d40e05a22b426f5db293fb..9c859099287cf836bf85217489d2e5045e65ef92 100644 (file)
@@ -25,7 +25,7 @@
 
 extern const char *idx2str(const CkArrayIndex &ind);
 extern const char *idx2str(const ArrayElement *el);
-const char *idx2str(const CkArrayIndexMax &ind){
+const char *idx2str(const CkArrayIndex &ind){
        return idx2str((const CkArrayIndex &)ind);
 };
 
@@ -1549,7 +1549,7 @@ private:
 public:
                ElementPacker(CkLocMgr* mgr_, PUP::er &p_):locMgr(mgr_),p(p_){};
                void addLocation(CkLocation &loc) {
-                       CkArrayIndexMax idx=loc.getIndex();
+                       CkArrayIndex idx=loc.getIndex();
                        CkGroupID gID = locMgr->ckGetGroupID();
                        p|gID;      // store loc mgr's GID as well for easier restore
                        p|idx;
@@ -1584,7 +1584,7 @@ void pupArrayElementsSkip(PUP::er &p, CmiBool create, MigrationRecord *listToSki
        
                for (int i=0; i<numElements; i++) {
                        CkGroupID gID;
-                       CkArrayIndexMax idx;
+                       CkArrayIndex idx;
                        p|gID;
                p|idx;
                        int flag=0;
@@ -2436,7 +2436,7 @@ void updateHomePE(void *data,ChareMlogData *mlogData){
        if(mlogData->objID.type == TypeArray){
                //it is an array element
                CkGroupID myGID = mlogData->objID.data.array.id;
-               CkArrayIndexMax myIdx =  mlogData->objID.data.array.idx;
+               CkArrayIndex myIdx =  mlogData->objID.data.array.idx;
                CkArrayID aid(mlogData->objID.data.array.id);           
                //check if the restarted processor is the home processor for this object
                CkLocMgr *locMgr = aid.ckLocalBranch()->getLocMgr();
@@ -2970,7 +2970,7 @@ class ElementDistributor: public CkLocIterator{
        CkLocMgr *locMgr;
        int *targetPE;
        void pupLocation(CkLocation &loc,PUP::er &p){
-               CkArrayIndexMax idx=loc.getIndex();
+               CkArrayIndex idx=loc.getIndex();
                CkGroupID gID = locMgr->ckGetGroupID();
                p|gID;      // store loc mgr's GID as well for easier restore
                p|idx;
@@ -2984,7 +2984,7 @@ class ElementDistributor: public CkLocIterator{
                                return;
                        }
                        
-                       CkArrayIndexMax idx=loc.getIndex();
+                       CkArrayIndex idx=loc.getIndex();
                        CkLocRec_local *rec = loc.getLocalRecord();
                        
                        CkPrintf("[%d] Distributing objects to Processor %d: ",CkMyPe(),*targetPE);
@@ -3031,7 +3031,7 @@ void _distributedLocationHandler(char *receivedMsg){
        char *buf = &receivedMsg[CmiMsgHeaderSizeBytes];
        PUP::fromMem pmem(buf);
        CkGroupID gID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        pmem |gID;
        pmem |idx;
        CkLocMgr *mgr = (CkLocMgr*)CkpvAccess(_groupTable)->find(gID).getObj();
@@ -3060,7 +3060,7 @@ void _distributedLocationHandler(char *receivedMsg){
 
 /** this method is used to send messages to a restarted processor to tell
  * it that a particular expected object is not going to get to it */
-void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndexMax &idx,int locationPE){
+void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndex &idx,int locationPE){
        DummyMigrationMsg buf;
        buf.flag = MLOG_OBJECT;
        buf.lbID = lbID;
@@ -3348,7 +3348,7 @@ void _checkpointBarrierAckHandler(CheckpointBarrierMsg *msg){
        It is a converse method to bypass the charm++ message logging framework
 */
 
-void informLocationHome(CkGroupID locMgrID,CkArrayIndexMax idx,int homePE,int currentPE){
+void informLocationHome(CkGroupID locMgrID,CkArrayIndex idx,int homePE,int currentPE){
        double _startTime = CmiWallTimer();
        CurrentLocationMsg msg;
        msg.mgrID = locMgrID;
@@ -3522,7 +3522,7 @@ char *CkObjID::toString(char *buf) const {
                        break;
                case TypeArray:
                        {
-                               const CkArrayIndexMax &idx = data.array.idx;
+                               const CkArrayIndex &idx = data.array.idx;
                                const int *indexData = idx.data();
                                sprintf(buf,"Array |%d %d %d| id %d \0",indexData[0],indexData[1],indexData[2],data.array.id.idx);
                                break;
index 5a55ff1b72a14819f077c02a79dfe091ea05f7b0..4c44bbe6cccb4a6a9ba3a31065fecf8d804d07aa 100644 (file)
@@ -256,7 +256,7 @@ public:
  */
 class LocationID{
 public:
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        CkGroupID gid;
 };
 
@@ -404,7 +404,7 @@ typedef struct{
 
 typedef struct {
        CkGroupID gID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int fromPE,toPE;
        char ackFrom,ackTo;
 } MigrationRecord;
@@ -445,7 +445,7 @@ typedef struct {
 typedef struct {
        char header[CmiMsgHeaderSizeBytes];
        CkGroupID mgrID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int locationPE;
        int fromPE;
 } CurrentLocationMsg;
@@ -468,7 +468,7 @@ typedef struct {
        int count;// if just count
        /**if object **/
        CkGroupID mgrID;
-       CkArrayIndexMax idx;
+       CkArrayIndex idx;
        int locationPE;
 } DummyMigrationMsg;
 
@@ -559,7 +559,7 @@ void processReceivedTN(Chare *obj,int vecsize,MCount *listTNs);
 void initializeRestart(void *data,ChareMlogData *mlogData);
 void distributeRestartedObjects();
 void sortRestoredLocalMsgLog(void *_dummy,ChareMlogData *mlogData);
-void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndexMax &idx,int locationPE);
+void sendDummyMigration(int restartPE,CkGroupID lbID,CkGroupID locMgrID,CkArrayIndex &idx,int locationPE);
 
 //TML: function for locally calling the restart
 void CkMlogRestartLocal();
@@ -640,7 +640,7 @@ extern void _initDone(void);
 extern void _resetNodeBocInitVec(void);
 
 //methods for updating location
-void informLocationHome(CkGroupID mgrID,CkArrayIndexMax idx,int homePE,int currentPE);
+void informLocationHome(CkGroupID mgrID,CkArrayIndex idx,int homePE,int currentPE);
 
 //handlers for updating locations
 void _receiveLocationHandler(CurrentLocationMsg *data);
index 0559f12a96ce83af2447384b6627aedd7a16d1a9..06a7a56438d13d8e59f08f30756d2dab8ab2c81e 100644 (file)
@@ -169,7 +169,7 @@ class CkSectionID {
         /// Minimal section info
         CkSectionInfo _cookie;
         /// The list of array indices that are section members
-        CkArrayIndexMax *_elems;
+        CkArrayIndex *_elems;
         /// The number of section members
         int _nElems;
         /** A list of PEs that host section members
index 2c62bb1de213f35d216e9e6610403903670f2874..aab6c6862f93617b31d335a16d06c675da5fd1d9 100644 (file)
@@ -346,8 +346,8 @@ private:
     int getArrayIfNotThere(void) {return type.array.ifNotThere;}
     void setArrayIfNotThere(int nt) {type.array.ifNotThere=nt;}
     int *getsetArrayListenerData(void) {return type.array.listenerData;}
-    CkArrayIndexMax &getsetArrayIndex(void) 
-       {return *(CkArrayIndexMax *)&type.array.index;}
+    CkArrayIndex &getsetArrayIndex(void) 
+       {return *(CkArrayIndex *)&type.array.index;}
 
 #ifdef USE_CRITICAL_PATH_HEADER_ARRAY
  public:
index 7fb07e14e829be976ee844ef848a727b6cc018a3..54c2f7dd37c36df93aa3d26edcfe3da930cf6c89 100644 (file)
@@ -66,7 +66,7 @@
   void * CkCacheManager::requestData(CkCacheKey what, CkArrayIndex &_toWhom, int chunk, CkCacheEntryType *type, CkCacheRequestorData &req){
 
     std::map<CkCacheKey,CkCacheEntry *>::iterator p;
-    CkArrayIndexMax toWhom(_toWhom);
+    CkArrayIndex toWhom(_toWhom);
     CkAssert(chunkAck[chunk] > 0);
     p = cacheTable[chunk].find(what);
     CkCacheEntry *e;
     e->requestorVec.clear();
   }
 
-  void CkCacheManager::cacheSync(int &_numChunks, CkArrayIndexMax &chareIdx, int &localIdx) {
+  void CkCacheManager::cacheSync(int &_numChunks, CkArrayIndex &chareIdx, int &localIdx) {
     finishedChunks = 0;
     if (syncdChares > 0) {
       _numChunks = numChunks;
index dfc3686fd136d395920a767c3a4c1ee2cfbd07c9..0b04dfc4dd2451512643e44f02164357f1600c8f 100644 (file)
@@ -8,11 +8,11 @@ module CkCache {
     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, CkArrayIndexMax &toWhom, int chunk, CkCacheEntryType *type, CkCacheRequestorData &req);
+    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, CkArrayIndexMax &chareIdx, int &localIdx);
+    entry [local] void cacheSync(int &numChunks, CkArrayIndex &chareIdx, int &localIdx);
     entry void recvData(CkCacheFillMsg *msg);
-    entry [local] void recvData(CkCacheKey key, CkArrayIndexMax &from, CkCacheEntryType *type, int chunk, void *data);
+    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);
     entry void collectStatistics(CkCallback &cb);
index ccbbbaa3623a524001f4adff26a8cb9a73048f96..83d19d1e7a5f9d0ea66d311cba51880c4be5ec65 100644 (file)
@@ -102,14 +102,14 @@ public:
   CkCacheFillMsg (CkCacheKey k) : key(k) {}
 };
 
-typedef void (*CkCacheCallback)(CkArrayID, CkArrayIndexMax&, CkCacheKey, CkCacheUserData &, void*, int);
+typedef void (*CkCacheCallback)(CkArrayID, CkArrayIndex&, CkCacheKey, CkCacheUserData &, void*, int);
 
 class CkCacheRequestorData {
 public:
   CkCacheUserData userData;
   CkCacheCallback fn;
   CkArrayID requestorID;
-  CkArrayIndexMax requestorIdx;
+  CkArrayIndex requestorIdx;
 
   CkCacheRequestorData(CProxyElement_ArrayElement &el, CkCacheCallback f, CkCacheUserData &data) {
     userData = data;
@@ -125,9 +125,9 @@ public:
 
 class CkCacheEntryType {
 public:
-  virtual void * request(CkArrayIndexMax&, CkCacheKey) = 0;
-  virtual void * unpack(CkCacheFillMsg *, int, CkArrayIndexMax &) = 0;
-  virtual void writeback(CkArrayIndexMax&, CkCacheKey, void *) = 0;
+  virtual void * request(CkArrayIndex&, CkCacheKey) = 0;
+  virtual void * unpack(CkCacheFillMsg *, int, CkArrayIndex &) = 0;
+  virtual void writeback(CkArrayIndex&, CkCacheKey, void *) = 0;
   virtual void free(void *) = 0;
   virtual int size(void *) = 0;
 };
@@ -135,7 +135,7 @@ public:
 class CkCacheEntry {
 public:
   CkCacheKey key;
-  CkArrayIndexMax home;
+  CkArrayIndex home;
   CkCacheEntryType *type;
   std::vector<CkCacheRequestorData> requestorVec;
 
@@ -180,7 +180,7 @@ public:
 class CkCacheArrayCounter : public CkLocIterator {
 public:
   int count;
-  CkHashtableT<CkArrayIndexMax, int> registered;
+  CkHashtableT<CkArrayIndex, int> registered;
   CkCacheArrayCounter() : count(0) { }
   void addLocation(CkLocation &loc) {
     registered.put(loc.getIndex()) = ++count;
@@ -283,7 +283,7 @@ class CkCacheManager : public CBase_CkCacheManager {
   void recvData(CkCacheFillMsg *msg);
   void recvData(CkCacheKey key, CkArrayIndex &from, CkCacheEntryType *type, int chunk, void *data);
 
-  void cacheSync(int &numChunks, CkArrayIndexMax &chareIdx, int &localIdx);
+  void cacheSync(int &numChunks, CkArrayIndex &chareIdx, int &localIdx);
 
   /** Called from the TreePieces to acknowledge that a particular chunk
       can be written back to the original senders */
index 5efd8685b8b36adbd4398381dec514b650fd6090..898fe468175d49f7f7dcef5fdfaf38112e966eee 100644 (file)
@@ -31,7 +31,7 @@
 #define MAXFRAGS 20
 
 typedef CkQ<multicastGrpMsg *>   multicastGrpMsgBuf;
-typedef CkVec<CkArrayIndexMax>   arrayIndexList;
+typedef CkVec<CkArrayIndex>   arrayIndexList;
 typedef CkVec<CkSectionInfo>     sectionIdList;
 typedef CkVec<CkReductionMsg *>  reductionMsgs;
 typedef CkQ<int>                 PieceSize;
@@ -194,7 +194,7 @@ public:
 class multicastSetupMsg: public CMessage_multicastSetupMsg {
 public:
   int  nIdx;
-  CkArrayIndexMax *arrIdx;
+  CkArrayIndex *arrIdx;
   int      *lastKnown;
   CkSectionInfo parent;
   CkSectionInfo rootSid;
@@ -251,7 +251,7 @@ extern LDObjid idx2LDObjid(const CkArrayIndex &idx);    // cklocation.C
 
 
 
-void CkMulticastMgr::setSection(CkSectionInfo &_id, CkArrayID aid, CkArrayIndexMax *al, int n)
+void CkMulticastMgr::setSection(CkSectionInfo &_id, CkArrayID aid, CkArrayIndex *al, int n)
 {
     // Create a multicast entry
     mCastEntry *entry = new mCastEntry(aid);
@@ -289,7 +289,7 @@ void CkMulticastMgr::setSection(CProxySection_ArrayElement &proxy)
 
   mCastEntry *entry = new mCastEntry(aid);
 
-  const CkArrayIndexMax *al = proxy.ckGetArrayElements();
+  const CkArrayIndex *al = proxy.ckGetArrayElements();
   for (int i=0; i<proxy.ckGetNumElements(); i++) {
     entry->allElem.push_back(al[i]);
 #if CMK_LBDB_ON
@@ -320,7 +320,7 @@ void CkMulticastMgr::resetSection(CProxySection_ArrayElement &proxy)
   mCastEntry *oldentry = (mCastEntry *)info.get_val();
   DEBUGF(("[%d] resetSection: old entry:%p new entry:%p\n", CkMyPe(), oldentry, entry));
 
-  const CkArrayIndexMax *al = sid->_elems;
+  const CkArrayIndex *al = sid->_elems;
   CmiAssert(info.aid == aid);
   prepareCookie(entry, *sid, al, sid->_nElems, aid);
 
@@ -340,7 +340,7 @@ void CkMulticastMgr::resetSection(CProxySection_ArrayElement &proxy)
 
 
 /// Build a mCastEntry object with relevant section info and set the section cookie to point to this object
-void CkMulticastMgr::prepareCookie(mCastEntry *entry, CkSectionID &sid, const CkArrayIndexMax *al, int count, CkArrayID aid)
+void CkMulticastMgr::prepareCookie(mCastEntry *entry, CkSectionID &sid, const CkArrayIndex *al, int count, CkArrayID aid)
 {
   for (int i=0; i<count; i++) {
     entry->allElem.push_back(al[i]);
@@ -368,7 +368,7 @@ void CkMulticastMgr::initDelegateMgr(CProxy *cproxy)
       CkArrayID aid = proxy->ckGetArrayIDn(i);
       mCastEntry *entry = new mCastEntry(aid);
       CkSectionID *sid = &( proxy->ckGetSectionID(i) );
-      const CkArrayIndexMax *al = proxy->ckGetArrayElements(i);
+      const CkArrayIndex *al = proxy->ckGetArrayElements(i);
       prepareCookie(entry, *sid, al, proxy->ckGetNumElements(i), aid);
       initCookie(sid->_cookie);
   }
index d4945b4edab93a7ac206cefb19798607811d9989..783a050ea2b1c8b9d28a67f7f1d80fa25f2ca49d 100644 (file)
@@ -2,7 +2,7 @@
 module CkMulticast {
   message cookieMsg;
   message multicastSetupMsg {
-    CkArrayIndexMax arrIdx[];
+    CkArrayIndex arrIdx[];
     int  lastKnown[];
   };
   message multicastGrpMsg;
index b6567dbe7ca3bac794f68ea993d1f0b91e0a82c0..549a118fffe077952f58ec295fd699a0c961d859 100644 (file)
@@ -35,12 +35,12 @@ class CkMulticastMgr: public CkDelegateMgr
         /// Internal class for the (array index, location) pair.
         class IndexPos {
             public:
-                CkArrayIndexMax idx;
+                CkArrayIndex idx;
                 int  pe;
             public:
                 IndexPos() {}
                 IndexPos(int i): idx(), pe(i) {}
-                IndexPos(CkArrayIndexMax i, int p): idx(i), pe(p) {};
+                IndexPos(CkArrayIndex i, int p): idx(i), pe(p) {};
                 void pup(PUP::er &p){ p|idx; p|pe; }
         };
         typedef CkVec<IndexPos>  arrayIndexPosList;
@@ -59,7 +59,7 @@ class CkMulticastMgr: public CkDelegateMgr
 
         // ------------------------- Spanning Tree Setup ------------------------
         /// Stuff section member info into CkSectionInfo and call initCookie for the tree building
-        void setSection(CkSectionInfo &id, CkArrayID aid, CkArrayIndexMax *, int n);
+        void setSection(CkSectionInfo &id, CkArrayID aid, CkArrayIndex *, int n);
         /// Call initCookie to start the tree build
         void setSection(CkSectionInfo &id);
         /// @deprecated { Use the other setSection methods }
@@ -116,7 +116,7 @@ class CkMulticastMgr: public CkDelegateMgr
 
     private:
         /// Fill the SectionInfo cookie in the SectionID obj with relevant info
-        void prepareCookie(mCastEntry *entry, CkSectionID &sid, const CkArrayIndexMax *al, int count, CkArrayID aid);
+        void prepareCookie(mCastEntry *entry, CkSectionID &sid, const CkArrayIndex *al, int count, CkArrayID aid);
         /// Get info from the CkSectionInfo and call setup() to start the spanning tree build
         void initCookie(CkSectionInfo sid);
         /// Actually trigger the multicast to a section of a chare array
index cca4e104e90e0e3272de0181908768212417c5d6..ef8ebefed1f6e50dfce3ea6ec0e47597e7e24add 100644 (file)
@@ -10,7 +10,7 @@ CkArrayID taskGraphInit() {
   return CProxy_taskGraphArray::ckNew();
 }
 
-void taskGraphDelete(CkArrayID id, CkArrayIndexMax taskID) {
+void taskGraphDelete(CkArrayID id, CkArrayIndex taskID) {
   CProxy_taskGraphArray array(id);
   array(taskID).deleteElement();
 }
@@ -19,7 +19,7 @@ void taskGraphDelete(CkArrayID id, CkArrayIndexMax taskID) {
  * Now define the taskGraphArray that actually handles doing all that work.
  */
 taskGraphArray::taskGraphArray(
-       CkVec<CkArrayIndexMax> deps,
+       CkVec<CkArrayIndex> deps,
        taskGraphSolver *data,
        CkCallback returnResults
 ) : Waiting() {
@@ -66,7 +66,7 @@ void taskGraphArray::tryToSolve() {
 }
 
 
-void taskGraphArray::requestData(CkArrayIndexMax from) {
+void taskGraphArray::requestData(CkArrayIndex from) {
   // If the problem isn't solved, kick this request onto the waiting queue
   if ( ! isSolved ) {
     Waiting.insertAtEnd(from);
index 30d606ac84e2bce74d0b579590bfc93d3cc2e81b..ded1dbb7e7218526005c0938b8edd7a7af7439f8 100644 (file)
@@ -2,10 +2,10 @@ module taskGraph {
   message callbackMsg;
 
   array [Max] taskGraphArray {
-    entry taskGraphArray(CkVec<CkArrayIndexMax> deps,
+    entry taskGraphArray(CkVec<CkArrayIndex> deps,
                         CkPointer<taskGraphSolver> data,
                         CkCallback returnResults);
-    entry void requestData(CkArrayIndexMax from);
+    entry void requestData(CkArrayIndex from);
     entry void depositData(CkPointer<taskGraphSolver> data);
     entry void deleteElement();
   };
index f4c7ebb74046fd228f6714b5455c30187202a8bc..c81d61ebdbbd89acb2d16723a5a203e45a730ead 100644 (file)
@@ -18,13 +18,13 @@ class taskGraphSolver; // forward decl so taskGraph.decl.h doesn't die
 class taskGraphSolver : public PUP::able {
 private:
   CkArrayID __taskSet;
-  CkArrayIndexMax __taskIndex;
-  CkVec<CkArrayIndexMax> __taskDeps;
+  CkArrayIndex __taskIndex;
+  CkVec<CkArrayIndex> __taskDeps;
 public:
   virtual void dependsOn(int x) { dependsOn(CkArrayIndex1D(x)); }
   virtual void dependsOn(int x, int y) { dependsOn(CkArrayIndex2D(x,y)); }
   virtual void dependsOn(int x, int y, int z) { dependsOn(CkArrayIndex3D(x,y,z)); }
-  virtual void dependsOn(CkArrayIndexMax taskDep) { __taskDeps.push_back(CkArrayIndexMax(taskDep)); }
+  virtual void dependsOn(CkArrayIndex taskDep) { __taskDeps.push_back(CkArrayIndex(taskDep)); }
 
   static CkArrayID newTaskGraph() { return CProxy_taskGraphArray::ckNew(); }
   virtual void startTask() {
@@ -43,7 +43,7 @@ public:
     : __taskDeps(), __taskSet(set), __taskIndex(CkArrayIndex2D(x,y)) {};
   taskGraphSolver(CkArrayID set, int x, int y, int z)
     : __taskDeps(), __taskSet(set), __taskIndex(CkArrayIndex3D(x,y,z)) {};
-  taskGraphSolver(CkArrayID set, CkArrayIndexMax taskIndex)
+  taskGraphSolver(CkArrayID set, CkArrayIndex taskIndex)
     : __taskDeps(), __taskSet(set), __taskIndex(taskIndex) {};
   taskGraphSolver(CkMigrateMessage *m) : PUP::able(m) {};
 
@@ -60,8 +60,8 @@ public:
 class callbackMsg : public CMessage_callbackMsg {
 public:
   PUPable_marshall<taskGraphSolver> Data;
-  CkArrayIndexMax Index;
-  callbackMsg(taskGraphSolver* self, CkArrayIndexMax ind)
+  CkArrayIndex Index;
+  callbackMsg(taskGraphSolver* self, CkArrayIndex ind)
     : Data(self), Index(ind) {};
 };
 
@@ -87,13 +87,13 @@ void taskGraphAdd(CkArrayID id, T taskID,
                  CkVec<T> deps,
                  taskGraphSolver *self,
                  CkCallback returnResults = CkCallback::ignore) {
-  CkVec<CkArrayIndexMax> newDeps;
+  CkVec<CkArrayIndex> newDeps;
 
   for ( int i = 0 ; i < deps.length() ; i++ ) {
-    newDeps.push_back( CkArrayIndexMax(deps[i]) );
+    newDeps.push_back( CkArrayIndex(deps[i]) );
   }
 
-  CkArrayIndexMax newTaskID( taskID );
+  CkArrayIndex newTaskID( taskID );
   CProxy_taskGraphArray array(id);
   array(newTaskID).insert(newDeps, self, returnResults);
 }
@@ -101,7 +101,7 @@ void taskGraphAdd(CkArrayID id, T taskID,
 /*
  * Delete an old task. The array ID and task number to delete are required.
  */
-void taskGraphDelete(CkArrayID id, CkArrayIndexMax taskID);
+void taskGraphDelete(CkArrayID id, CkArrayIndex taskID);
 
 
 /*
@@ -111,7 +111,7 @@ class taskGraphArray : public ArrayElementMax {
 protected:
   taskGraphSolver *Self;
   int isSolved;
-  CkVec<CkArrayIndexMax> Waiting;
+  CkVec<CkArrayIndex> Waiting;
 
   int DepsCount;
   taskGraphSolver **DepsData;
@@ -122,11 +122,11 @@ protected:
   void tryToSolve();
 
 public:
-  taskGraphArray(CkVec<CkArrayIndexMax> deps,
+  taskGraphArray(CkVec<CkArrayIndex> deps,
                  taskGraphSolver *data,
                 CkCallback returnResults);
   taskGraphArray(CkMigrateMessage *m) {};
-  void requestData(CkArrayIndexMax from);
+  void requestData(CkArrayIndex from);
   void depositData(taskGraphSolver *data);
   void deleteElement();
 };
index 33c31b5bbf664c9976f1531098900f817c26ba06..d4f2db97d9ee946bf4939b81961ee3ebb3c8a3b0 100644 (file)
@@ -1511,9 +1511,9 @@ Array::genSubDecls(XStr& str)
        << "  { return " << super << "::ckGetSectionID(i); }\n"
        << "inline CkArrayID ckGetArrayIDn(int i) const\n"
        << "{return " << super << "::ckGetArrayIDn(i); } \n"
-       << "inline CkArrayIndexMax *ckGetArrayElements() const\n"
+       << "inline CkArrayIndex *ckGetArrayElements() const\n"
        << "  { return " << super << "::ckGetArrayElements(); }\n"
-       << "inline CkArrayIndexMax *ckGetArrayElements(int i) const\n"
+       << "inline CkArrayIndex *ckGetArrayElements(int i) const\n"
        << "{return " << super << "::ckGetArrayElements(i); }\n"
        << "inline int ckGetNumElements() const\n"
        << "  { return " << super << "::ckGetNumElements(); } \n"
@@ -1629,18 +1629,18 @@ Array::genSubDecls(XStr& str)
     "    } \n";
     }
 
-    str <<"    "<<ptype<<"(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems, CK_DELCTOR_PARAM) \n"
+    str <<"    "<<ptype<<"(const CkArrayID &aid, CkArrayIndex *elems, int nElems, CK_DELCTOR_PARAM) \n"
          "        :";genProxyNames(str, "",NULL, "(aid,elems,nElems,CK_DELCTOR_ARGS)", ", ");str << " {}\n";
-    str <<"    "<<ptype<<"(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems) \n"
+    str <<"    "<<ptype<<"(const CkArrayID &aid, CkArrayIndex *elems, int nElems) \n"
          "        :";genProxyNames(str, "",NULL, "(aid,elems,nElems)", ", ");str<<" {}\n";
     str <<"    "<<ptype<<"(const CkSectionID &sid)"
          "       :";genProxyNames(str, "",NULL, "(sid)", ", ");str<< " {}\n";
-       str <<"    "<<ptype<<"(int n, const CkArrayID *aid, CkArrayIndexMax const * const *elems, const int *nElems, CK_DELCTOR_PARAM) \n"
+       str <<"    "<<ptype<<"(int n, const CkArrayID *aid, CkArrayIndex const * const *elems, const int *nElems, CK_DELCTOR_PARAM) \n"
          "        :";genProxyNames(str, "",NULL, "(n,aid,elems,nElems,CK_DELCTOR_ARGS)", ", ");str << " {}\n";
-       str <<"    "<<ptype<<"(int n, const CkArrayID *aid, CkArrayIndexMax const * const *elems, const int *nElems) \n"
+       str <<"    "<<ptype<<"(int n, const CkArrayID *aid, CkArrayIndex const * const *elems, const int *nElems) \n"
          "        :";genProxyNames(str, "",NULL, "(n,aid,elems,nElems)", ", ");str<<" {}\n";
     str <<
-    "    static CkSectionID ckNew(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems) {\n"
+    "    static CkSectionID ckNew(const CkArrayID &aid, CkArrayIndex *elems, int nElems) {\n"
     "      return CkSectionID(aid, elems, nElems);\n"
     "    } \n";
   }
@@ -3202,7 +3202,7 @@ void Entry::genArrayDefs(XStr& str)
       str << "#endif\n";
       if (!isNoTrace())
          str << "  _TRACE_BEGIN_EXECUTE_DETAILED(0,ForArrayEltMsg," << epIdx()
-             << ",CkMyPe(), 0, ((CkArrayIndexMax&)ckGetIndex()).getProjectionID(((CkGroupID)ckGetArrayID()).idx));\n";
+             << ",CkMyPe(), 0, ((CkArrayIndex&)ckGetIndex()).getProjectionID(((CkGroupID)ckGetArrayID()).idx));\n";
       str << "#if CMK_LBDB_ON\n  objHandle = obj->timingBeforeCall(&objstopped);\n#endif\n";
       str << "#if CMK_CHARMDEBUG\n"
       "  CpdBeforeEp("<<epIdx()<<", obj, NULL);\n"
index c4ad33393ae3f67bef7731e9100fdc4c97092c7b..70772b1a78df3a6454c8bb3253289ee53b63dbea 100644 (file)
@@ -105,7 +105,7 @@ public:
         arr = CProxy_Bench::ckNew();
         
         int count = 0;
-        CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements];
+        CkArrayIndex *elem_array = new CkArrayIndex[nElements];
         for(count = 0; count < nElements; count ++) {
             elem_array[count] = CkArrayIndex1D(count);
         }
index 62139ca5aafa1176b0ebc90bfd203bd887956454..0842f139b1c2df3d5c69e84ac4daf877bcf3563b 100644 (file)
@@ -88,7 +88,7 @@ public:
        arr = CProxy_Bench::ckNew();
                 
         int count = 0;
-        CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements];
+        CkArrayIndex *elem_array = new CkArrayIndex[nElements];
         for(count = 0; count < nElements; count ++) {
             elem_array[count] = CkArrayIndex1D(count);
         }
@@ -213,7 +213,7 @@ public:
         arrd = thisProxy;
         ComlibDelegateProxy(&arrd);
 
-        CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements];
+        CkArrayIndex *elem_array = new CkArrayIndex[nElements];
         for(int count = 0; count < nElements; count ++) 
             elem_array[count] = CkArrayIndex1D(count);
         
index 1830cf659f19fe206523c91f3b4445a17f57dbcd..a528012b683b193b58b442387f45a9eba049b53b 100644 (file)
@@ -91,7 +91,7 @@ public:
        arr = CProxy_Bench::ckNew();
                 
         int count = 0;
-        CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements];
+        CkArrayIndex *elem_array = new CkArrayIndex[nElements];
         for(count = 0; count < nElements; count ++) {
             elem_array[count] = CkArrayIndex1D(count);
         }
@@ -202,7 +202,7 @@ public:
         firstEntryFlag = 0;
         sendFinishedFlag = 0;
 
-        CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements];
+        CkArrayIndex *elem_array = new CkArrayIndex[nElements];
         for(int count = 0; count < nElements; count ++) 
             elem_array[count] = CkArrayIndex1D(count);
         
index 22fba033af2b9a1242e9f9c02f7bd305393c0a91..f7040cd733dca2898f7730ca5f9052d6ebc26066 100644 (file)
@@ -40,7 +40,7 @@ public:
 
     mainProxy = thishandle;
        
-    CkArrayIndexMax *allElts = new CkArrayIndexMax[nElements];
+    CkArrayIndex *allElts = new CkArrayIndex[nElements];
     for (int i = 0; i<nElements; i++) {
        CkArrayIndex1D index = i;
        allElts[i] = index;
index 238c7a66a9cf9ccfc05040dbb49302142796d195..fa5dc0d134dac634f5b2cd41c22870ec4687c746 100644 (file)
@@ -55,7 +55,7 @@ public:
 
     // create eachToMany strategy for Array
     
-    CkArrayIndexMax *allElts = new CkArrayIndexMax[nElements];
+    CkArrayIndex *allElts = new CkArrayIndex[nElements];
     for (int i = 0; i<nElements; i++) {
        allElts[i].data()[0] = i;
        allElts[i].data()[1] = 0;
index 4f7daabd4998af420f3f8c7549cc222b9cd1cbf1..56dbe61ebdb086210cfb0fff01c9c8789f43cc37 100644 (file)
@@ -57,7 +57,7 @@ public:
     eachToManyArrayProxy = CProxy_EachToManyArray::ckNew(nElements);
 
     // Create a strategy
-    CkArrayIndexMax *allElts = new CkArrayIndexMax[nElements];
+    CkArrayIndex *allElts = new CkArrayIndex[nElements];
     for (int i = 0; i<nElements; i++) {
        CkArrayIndex1D index = i;
        allElts[i] = index;
index 1af4cd59f655cfe5ab8c1b99568c7daaa9fe79fc..d3579f85e490bf5ab08b6d4369b3a68c7d387a80 100644 (file)
@@ -103,7 +103,7 @@ public:
     testProxy4dest = CProxy_EachToManyArray::ckNew(nElements);
     
     
-    CkArrayIndexMax *allElts = new CkArrayIndexMax[nElements];
+    CkArrayIndex *allElts = new CkArrayIndex[nElements];
     for (int i = 0; i<nElements; i++) {
        CkArrayIndex1D index = i;
        allElts[i] = index;
index 3c67d200b9e7000e71dcd4cc58b88b9137d5fed5..e78513b82a29de7ddf6215f564980543f19497a2 100644 (file)
@@ -41,7 +41,7 @@ public:
 class DelegateMgr : public CkDelegateMgr {
 public:
        DelegateMgr(void) {}
-       virtual void ArraySend(int ep,void *m,const CkArrayIndexMax &idx,CkArrayID a)
+       virtual void ArraySend(int ep,void *m,const CkArrayIndex &idx,CkArrayID a)
        {
                CkArray *arrMgr=CProxy_CkArray(a).ckLocalBranch();
                int onPE=arrMgr->lastKnown(idx);
@@ -57,7 +57,7 @@ public:
                        CkFreeMsg(m);
                }
        }
-       void forwardMsg(int ep,const CkArrayIndexMax &idx,
+       void forwardMsg(int ep,const CkArrayIndex &idx,
                        const CkArrayID &a,
                        int nBytes,char *env)
        {
index 5e5194201f3cee956c9b4bf28ed459e27e6c6ba2..b898d335c76fef419fa04eeee82a170d28e6e544 100644 (file)
@@ -15,7 +15,7 @@ mainmodule hello {
   };
   group DelegateMgr {
     entry DelegateMgr(void);
-    entry void forwardMsg(int ep,CkArrayIndexMax idx,CkArrayID a,
+    entry void forwardMsg(int ep,CkArrayIndex idx,CkArrayID a,
        int nBytes,char msg[nBytes]);
   };
 };
index 4cb0093eb35696699e1b48b0ad140a0e373116f6..95246f7e3c352b323a5aa39020552ee54f2c6cef 100644 (file)
@@ -99,7 +99,7 @@ public:
 
     sectionSize = SectionSize;
     if (sectionSize > NumElements) sectionSize = NumElements;
-    CkArrayIndexMax *al = new CkArrayIndexMax[sectionSize];
+    CkArrayIndex *al = new CkArrayIndex[sectionSize];
     for (int i=0; i<sectionSize; i++) {
       al[i] = CkArrayIndex1D(i);
     }
index 74563770af37c032cc8823bd6a3c213fbff3ca1e..cc3fccabecf986de8fbc9825eb0d363810ab0dba 100644 (file)
@@ -73,10 +73,10 @@ void multisectiontest_init()
          //  sectionSize);
 
          // cross section lower half of each array
-         CkArrayIndexMax **aelems= new CkArrayIndexMax*[numarrays];
-         aelems[0]= new CkArrayIndexMax[asectionSize];
-         aelems[1]= new CkArrayIndexMax[asectionSize];
-         aelems[2]= new CkArrayIndexMax[asectionSize];
+         CkArrayIndex **aelems= new CkArrayIndex*[numarrays];
+         aelems[0]= new CkArrayIndex[asectionSize];
+         aelems[1]= new CkArrayIndex[asectionSize];
+         aelems[2]= new CkArrayIndex[asectionSize];
          int *naelems=new int[numarrays];
          for(int k=0;k<numarrays;k++)
            {
@@ -114,10 +114,10 @@ void multisectiontest_init()
 
          // cross section upper half of each array
          // cross section lower half of each array
-         CkArrayIndexMax **aelemsH= new CkArrayIndexMax*[numarrays];
-         aelemsH[0]= new CkArrayIndexMax[asectionSize];
-         aelemsH[1]= new CkArrayIndexMax[asectionSize];
-         aelemsH[2]= new CkArrayIndexMax[asectionSize];
+         CkArrayIndex **aelemsH= new CkArrayIndex*[numarrays];
+         aelemsH[0]= new CkArrayIndex[asectionSize];
+         aelemsH[1]= new CkArrayIndex[asectionSize];
+         aelemsH[2]= new CkArrayIndex[asectionSize];
          for(int k=0;k<numarrays;k++)
            {
              naelems[k]=asectionSize;
@@ -292,10 +292,10 @@ void multisectiontest_grp::recvID( multisectionAID_msg *m)
   //  CkPrintf("G(%d)[%d] bound %d floor %d ceiling %d sectionSize %d\n",thisProxy.ckGetGroupID().idx, CkMyPe(), boundary, floor, ceiling, sectionSize);
   //  CkPrintf("G(%d)[%d] abound %d afloor %d aceiling %d asectionSize %d\n",thisProxy.ckGetGroupID().idx, CkMyPe(),aboundary, afloor, aceiling, asectionSize);
 
-  CkArrayIndexMax **aelems= new CkArrayIndexMax*[NUMARRAYS];
-  aelems[0]= new CkArrayIndexMax[asectionSize];
-  aelems[1]= new CkArrayIndexMax[asectionSize];
-  aelems[2]= new CkArrayIndexMax[asectionSize];
+  CkArrayIndex **aelems= new CkArrayIndex*[NUMARRAYS];
+  aelems[0]= new CkArrayIndex[asectionSize];
+  aelems[1]= new CkArrayIndex[asectionSize];
+  aelems[2]= new CkArrayIndex[asectionSize];
   int *naelems=new int[NUMARRAYS];
   for(int k=0;k<NUMARRAYS;k++)
     {