Split nInts of CkArrayIndex into two shorts: the first one still named nInts, the...
authorFilippo Gioachin <gioachin@illinois.edu>
Tue, 12 May 2009 04:15:45 +0000 (04:15 +0000)
committerFilippo Gioachin <gioachin@illinois.edu>
Tue, 12 May 2009 04:15:45 +0000 (04:15 +0000)
Deleted some duplicated code (idx2str)

src/ck-core/charisma.h
src/ck-core/charm++.h
src/ck-core/ckarray.C
src/ck-core/ckarray.h
src/ck-core/cklocation.C
src/ck-core/cklocation.h

index 44f3d0f172773f22c242880353a1da09199706b0..f0a8c0fa32078614faac884bb621071f2d2a721c 100644 (file)
@@ -281,14 +281,17 @@ class CkArrayIndexCharisma: public CkArrayIndex
     CkArrayIndexCharisma(int _i) {
       i = _i; j = 0; k = 0;
       nInts = 1;
+      dimension = 1;
     }
     CkArrayIndexCharisma(int _i, int _j) {
       i = _i; j= _j; k= 0;
       nInts = 2;
+      dimension = 2;
     }
     CkArrayIndexCharisma(int _i, int _j, int _k) {
       i = _i; j = _j; k= _k;
       nInts = 3;
+      dimension = 3;
     }
 };
 
index 7bbe199cc317f3af0f2bf4080d16a298cdc3e16d..be24e48db64b606f1edd17ac30cac4df712eb435 100644 (file)
@@ -211,12 +211,14 @@ class CkArrayIndex
 {
 public:
         ///Length of index in *integers*
-       int nInts;
+       short int nInts;
+       ///Number of dimensions in this index, not valid for user-defined indices
+       short int dimension; 
        
        //Index data immediately follows...
        
-       int *data(void) {return (&nInts)+1;}
-       const int *data(void) const {return (&nInts)+1;}
+       int *data(void) {return (int*)((&nInts)+2);}
+       const int *data(void) const {return (int*)((&nInts)+2);}
 
         int getCombinedCount(void) const {
           if (nInts == 1) return data()[0];
@@ -271,12 +273,13 @@ class CkArrayIndexMax : public CkArrayIndex {
        void copyFrom(const CkArrayIndex &that)
        {
                nInts=that.nInts;
+               dimension=that.dimension;
                index=((const CkArrayIndexMax *)&that)->index;
                //for (int i=0;i<nInts;i++) index.data[i]=that.data()[i];
        }
 public:
-       CkArrayIndexMax(void) { nInts=0; }
-       CkArrayIndexMax(int i) { nInts=0; }   // used for CkVec
+       CkArrayIndexMax(void) { nInts=0; dimension=0; }
+       CkArrayIndexMax(int i) { nInts=0; dimension=0; }   // used for CkVec
        CkArrayIndexMax(const CkArrayIndex &that) 
                {copyFrom(that);}
        CkArrayIndexMax &operator=(const CkArrayIndex &that) 
@@ -284,6 +287,7 @@ public:
         void print() { CmiPrintf("%d: %d %d %d\n", nInts,index.data[0], index.data[1], index.data[2]); }
        void pup(PUP::er &p) {
                p|nInts;
+               p|dimension;
                for (int i=0;i<nInts;i++) p|index.data[i];
        }
        /*
@@ -346,7 +350,8 @@ PUPmarshall(CkArrayIndexMax)
 //  Needed, e.g., for use in unions where a constructor is forbidden.
 class CkArrayIndexStruct {
 public:
-       int nInts;
+       short int nInts;
+       short int dimension;
        int index[CK_ARRAYINDEX_MAXLEN];
        CkArrayIndexMax &asMax(void) 
                {return *(CkArrayIndexMax *)this;}
@@ -354,6 +359,7 @@ public:
                {return *(const CkArrayIndexMax *)this;}
        void pup(PUP::er &p) {
                p|nInts;
+               p|dimension;
                for (int i=0;i<nInts;i++) p|index[i];
        }
 };
@@ -1016,6 +1022,31 @@ if(CpvAccess(networkProgressCount) >=  p)  \
 #include "ckarrayreductionmgr.h"
 #include "trace.h"
 
+/************************** Debugging Utilities **************/
+
+//For debugging: convert given index to a string (NOT threadsafe)
+static const char *idx2str(const CkArrayIndex &ind) {
+  static char retBuf[80];
+  retBuf[0]=0;
+  if (ind.dimension <= 3) {
+    for (int i=0;i<ind.nInts;i++) {
+      if (i>0) strcat(retBuf,";");
+      sprintf(&retBuf[strlen(retBuf)],"%d",ind.data()[i]);
+    }
+  } else {
+    const short int *idx = (const short int*)ind.data();
+    for (int i=0;i<ind.dimension;i++) {
+      if (i>0) strcat(retBuf,";");
+      sprintf(&retBuf[strlen(retBuf)],"%hd",idx[i]);
+    }
+  }
+  return retBuf;
+}
+
+static const char *idx2str(const ArrayElement *el) {
+  return idx2str(el->thisIndexMax);
+}
+
 template <typename T>
 inline T *CkAllocateMarshallMsgT(int size,const CkEntryOptions *opts)
 {
index fc9459bb556225e6a9d54b8084831170fff66683..0dffc730048be79973b9d425afe4539f0a7e706b 100644 (file)
@@ -61,23 +61,6 @@ CpvDeclare(int ,serializer);
 
 CmiBool isAnytimeMigration;
 
-/************************** Debugging Utilities **************/
-
-//For debugging: convert given index to a string (NOT threadsafe)
-static const char *idx2str(const CkArrayIndex &ind)
-{
-  static char retBuf[80];
-  retBuf[0]=0;
-  for (int i=0;i<ind.nInts;i++)
-  {
-       if (i>0) strcat(retBuf,";");
-       sprintf(&retBuf[strlen(retBuf)],"%d",ind.data()[i]);
-  }
-  return retBuf;
-}
-static const char *idx2str(const ArrayElement *el)
-  {return idx2str(el->thisIndexMax);}
-
 #define ARRAY_DEBUG_OUTPUT 0
 
 #if ARRAY_DEBUG_OUTPUT 
@@ -105,11 +88,6 @@ static const char *idx2str(const ArrayElement *el)
 #   define DEBUG(x)
 #endif
 
-inline CkArrayIndexMax &CkArrayMessage::array_index(void)
-{
-       return UsrToEnv((void *)this)->getsetArrayIndex();
-}
-
 /*
 void 
 CProxyElement_ArrayBase::ckSendWrapper(void *me, void *m, int ep, int opts){
@@ -303,11 +281,15 @@ char *ArrayElement::ckDebugChareName(void) {
        char buf[200];
        const char *className=_chareTable[ckGetChareType()]->name;
        const int *d=thisIndexMax.data();
-       switch (thisIndexMax.nInts) {
+       const short int *s=(const short int*)d;
+       switch (thisIndexMax.dimension) {
        case 0: sprintf(buf,"%s",className); break;
        case 1: sprintf(buf,"%s[%d]",className,d[0]); break;
        case 2: sprintf(buf,"%s(%d,%d)",className,d[0],d[1]); break;
        case 3: sprintf(buf,"%s(%d,%d,%d)",className,d[0],d[1],d[2]); break;
+    case 4: sprintf(buf,"%s(%hd,%hd,%hd,%hd)",className,s[0],s[1],s[2],s[3]); break;
+    case 5: sprintf(buf,"%s(%hd,%hd,%hd,%hd,%hd)",className,s[0],s[1],s[2],s[3],s[4]); break;
+    case 6: sprintf(buf,"%s(%hd,%hd,%hd,%hd,%hd,%hd)",className,s[0],s[1],s[2],s[3],s[4],s[5]); break;
        default: sprintf(buf,"%s(%d,%d,%d,%d..)",className,d[0],d[1],d[2],d[3]); break;
        };
        return strdup(buf);
@@ -495,6 +477,7 @@ void CProxyElement_ArrayBase::pup(PUP::er &p)
 {
   CProxy_ArrayBase::pup(p);
   p|_idx.nInts;
+  p|_idx.dimension;
   p(_idx.data(),_idx.nInts);
 }
 
index c9f5c4737385604a930d88bc8463c43384387303..d822fec2855c5c5ba9e78d1c69fdf88d32528490 100644 (file)
@@ -50,78 +50,90 @@ All these classes are defined in ckarray.C.
 /// Simple ArrayIndex classes: the key is just integer indices.
 class CkArrayIndex1D : public CkArrayIndex {
 public: int index;
-       CkArrayIndex1D() { nInts=1; }
+       CkArrayIndex1D() { nInts=1; dimension=1; }
        CkArrayIndex1D(int i0) {
-               index=i0;nInts=1;
+               index=i0;nInts=1;dimension=1;
        }
        CkArrayIndex1D &operator=(const CkArrayIndex1D &that)  {
                CmiAssert(that.nInts == 1);
+               CmiAssert(that.dimension == 1);
                nInts = that.nInts;
+               dimension = that.dimension;
                index = that.index;
                return *this;
        }
 };
 class CkArrayIndex2D : public CkArrayIndex {
 public: int index[2];
-       CkArrayIndex2D() { nInts=2; }
+       CkArrayIndex2D() { nInts=2; dimension=2; }
        CkArrayIndex2D(int i0,int i1) {
-               index[0]=i0;index[1]=i1;nInts=2;
+               index[0]=i0;index[1]=i1;nInts=2;dimension=2;
        }
        CkArrayIndex2D &operator=(const CkArrayIndex2D &that)  {
                CmiAssert(that.nInts == 2);
+               CmiAssert(that.dimension == 2);
                nInts = that.nInts;
+               dimension = that.dimension;
                memcpy(index, that.index, sizeof(int)*2);
                return *this;
        }
 };
 class CkArrayIndex3D : public CkArrayIndex {
 public: int index[3];
-       CkArrayIndex3D() { nInts=3; }
+       CkArrayIndex3D() { nInts=3; dimension=3; }
        CkArrayIndex3D(int i0,int i1,int i2) {
-               index[0]=i0;index[1]=i1;index[2]=i2;nInts=3;
+               index[0]=i0;index[1]=i1;index[2]=i2;nInts=3;dimension=3;
        }
        CkArrayIndex3D &operator=(const CkArrayIndex3D &that)  {
                CmiAssert(that.nInts == 3);
+               CmiAssert(that.dimension == 3);
                nInts = that.nInts;
+               dimension = that.dimension;
                memcpy(index, that.index, sizeof(int)*3);
                return *this;
        }
 };
 class CkArrayIndex4D : public CkArrayIndex {
 public: short int index[4];
-       CkArrayIndex4D(){ nInts=2; }
+       CkArrayIndex4D(){ nInts=2; dimension=4; }
        CkArrayIndex4D(short int i0,short int i1,short int i2,short int i3) {
-               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;nInts=2;
+               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;nInts=2;dimension=4;
        }
        CkArrayIndex4D &operator=(const CkArrayIndex4D &that)  {
                CmiAssert(that.nInts == 2);
+               CmiAssert(that.dimension == 4);
                nInts = that.nInts;
+               dimension = that.dimension;
                memcpy(index, that.index, sizeof(short int)*4);
                return *this;
        }
 };
 class CkArrayIndex5D : public CkArrayIndex {
 public: short int index[5];
-       CkArrayIndex5D(){ nInts=3; }
+       CkArrayIndex5D(){ nInts=3; dimension=5; }
        CkArrayIndex5D(short int i0,short int i1,short int i2,short int i3,short int i4) {
-               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;index[4]=i4;nInts=3;
+               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;index[4]=i4;nInts=3;dimension=5;
         }
        CkArrayIndex5D &operator=(const CkArrayIndex5D &that)  {
                CmiAssert(that.nInts == 3);
+               CmiAssert(that.dimension == 5);
                nInts = that.nInts;
+               dimension = that.dimension;
                memcpy(index, that.index, sizeof(short int)*5);;
                return *this;
        }
 };
 class CkArrayIndex6D : public CkArrayIndex {
 public: short int index[6];
-       CkArrayIndex6D(){ nInts=3; }
+       CkArrayIndex6D(){ nInts=3; dimension=6; }
        CkArrayIndex6D(short int i0,short int i1,short int i2,short int i3,short int i4,short int i5) {
-               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;index[4]=i4;index[5]=i5;nInts=3;
+               index[0]=i0;index[1]=i1;index[2]=i2;index[3]=i3;index[4]=i4;index[5]=i5;nInts=3;dimension=6;
        }
        CkArrayIndex6D &operator=(const CkArrayIndex6D &that)  {
                CmiAssert(that.nInts == 3);
+               CmiAssert(that.dimension == 6);
                nInts = that.nInts;
+               dimension = that.dimension;
                memcpy(index, that.index, sizeof(short int)*6);;
                return *this;
        }
@@ -135,7 +147,8 @@ class CkArrayIndexT : public CkArrayIndex {
 public:
        object obj;
        CkArrayIndexT(const object &srcObj) {obj=srcObj;
-               nInts=sizeof(obj)/sizeof(int);}
+               nInts=sizeof(obj)/sizeof(int);
+               dimension=0; }
 };
 
 /********************* CkArrayListener ****************/
index ac3128f55a04452d75d9784e38f957c875c13d82..e65dda5e4470869724d49f01a21f03485fe80e51 100644 (file)
@@ -23,23 +23,8 @@ Orion Sky Lawlor, olawlor@acm.org 9/29/2001
 CpvExtern(void *, CkGridObject);
 #endif
 
-/************************** Debugging Utilities **************/
-//For debugging: convert given index to a string
-const char *idx2str(const CkArrayIndex &ind)
-{
-       static char retBuf[80];
-       retBuf[0]=0;
-       for (int i=0;i<ind.nInts;i++)
-       {
-               if (i>0) strcat(retBuf,";");
-               sprintf(&retBuf[strlen(retBuf)],"%d",ind.data()[i]);
-       }
-       return retBuf;
-}
-
-const char *idx2str(const CkArrayMessage *m)
-{
-       return idx2str(((CkArrayMessage *)m)->array_index());
+static const char *idx2str(const CkArrayMessage *m) {
+  return idx2str(((CkArrayMessage *)m)->array_index());
 }
 
 #define ARRAY_DEBUG_OUTPUT 0
@@ -117,13 +102,14 @@ int CkArrayIndex::staticCompare(const void *k1,const void *k2,size_t /*len*/)
 void CkArrayIndex::pup(PUP::er &p) 
 {
        p(nInts);
+       p(dimension);
        p(data(),nInts);
 }
 
 /*********************** Array Messages ************************/
-inline CkArrayIndexMax &CkArrayMessage::array_index(void)
+CkArrayIndexMax &CkArrayMessage::array_index(void)
 {
-       return UsrToEnv((void *)this)->getsetArrayIndex();
+    return UsrToEnv((void *)this)->getsetArrayIndex();
 }
 unsigned short &CkArrayMessage::array_ep(void)
 {
@@ -165,7 +151,7 @@ int CkArrayMap::registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
 #define CKARRAYMAP_POPULATE_INITIAL(POPULATE_CONDITION) \
         int i; \
        for (int i1=0; i1<numElements.data()[0]; i1++) { \
-          if (numElements.nInts == 1) { \
+          if (numElements.dimension == 1) { \
             /* Make 1D indices */ \
             i = i1; \
             CkArrayIndex1D idx(i1); \
@@ -174,7 +160,7 @@ int CkArrayMap::registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
           } else { \
             /* higher dimensionality */ \
             for (int i2=0; i2<numElements.data()[1]; i2++) { \
-              if (numElements.nInts == 2) { \
+              if (numElements.dimension == 2) { \
                 /* Make 2D indices */ \
                 i = i1 * numElements.data()[1] + i2; \
                 CkArrayIndex2D idx(i1, i2); \
@@ -182,7 +168,7 @@ int CkArrayMap::registerArray(CkArrayIndexMax& numElements,CkArrayID aid)
                   mgr->insertInitial(idx,CkCopyMsg(&ctorMsg)); \
               } else { \
                 /* higher dimensionality */ \
-                CkAssert(numElements.nInts == 3); \
+                CkAssert(numElements.dimension == 3); \
                 for (int i3=0; i3<numElements.data()[2]; i3++) { \
                   /* Make 3D indices */ \
                   i = (i1 * numElements.data()[1] + i2) * numElements.data()[2] + i3; \
@@ -324,7 +310,7 @@ public:
     } else if (i.nInts == 3) {
       flati = (i.data()[0] * arrs[arrayHdl]->_nelems.data()[1] + i.data()[1]) * arrs[arrayHdl]->_nelems.data()[2] + i.data()[2];
     } else {
-      CkAbort("CkArrayIndex has dimension greater than 3!");
+      CkAbort("CkArrayIndex has more than 3 integers!");
     }
 
     return (flati/arrs[arrayHdl]->_binSize);
@@ -358,7 +344,7 @@ public:
         } else if (numElements.nInts == 3) {
           binSize = (int)ceil((double)(numElements.data()[0]*numElements.data()[1]*numElements.data()[2])/(double)numPes);
         } else {
-          CkAbort("CkArrayIndex has dimension greater than 3!");
+          CkAbort("CkArrayIndex has more than 3 integers!");
         }
         CKARRAYMAP_POPULATE_INITIAL(i/binSize==thisPe);
 
@@ -927,7 +913,8 @@ CkMigratable::~CkMigratable() {
        }
 #endif
        //To detect use-after-delete
-       thisIndexMax.nInts=-123456;
+       thisIndexMax.nInts=-12345;
+       thisIndexMax.dimension=-12345;
 }
 
 void CkMigratable::CkAbort(const char *why) const {
@@ -1883,7 +1870,7 @@ void CkLocMgr::inform(const CkArrayIndex &idx,int nowOnPe)
        CkLocRec *rec=elementNrec(idx);
        if (rec!=NULL && rec->type()==CkLocRec::local){
 #ifdef _FAULT_MLOG_
-        CmiPrintf("[%d]WARNING!!! Element %d:%s is local but is being told it exists on %d\n",CkMyPe(),idx.nInts,idx2str(idx), nowOnPe);
+        CmiPrintf("[%d]WARNING!!! Element %d:%s is local but is being told it exists on %d\n",CkMyPe(),idx.dimension,idx2str(idx), nowOnPe);
 #endif
                return; //Never replace a local element's record!
        }
@@ -2463,7 +2450,7 @@ void CkLocMgr::emigrate(CkLocRec_local *rec,int toPe)
                p(nManagers);
                pupElementsFor(p,rec,CkElementCreation_migrate);
                if (p.size()!=bufSize) {
-                       CkError("ERROR! Array element claimed it was %d bytes to a"
+                       CkError("ERROR! Array element claimed it was %d bytes to a "
                                "sizing PUP::er, but copied %d bytes into the packing PUP::er!\n",
                                bufSize,p.size());
                        CkAbort("Array element's pup routine has a direction mismatch.\n");
index 4d0860496b07ae5cc33c9620667e5480632832bf..8768d06c73c4f83fc849a984a692112fe93f1e0e 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
-  inline CkArrayIndexMax &array_index(void);
+  CkArrayIndexMax &array_index(void);
   unsigned short &array_ep(void);
   unsigned short &array_ep_bcast(void);
   unsigned char &array_hops(void);