Added support for 4-, 5-, and 6-D chare array.
authorChao Huang <chuang10@uiuc.edu>
Wed, 23 Feb 2005 08:25:45 +0000 (08:25 +0000)
committerChao Huang <chuang10@uiuc.edu>
Wed, 23 Feb 2005 08:25:45 +0000 (08:25 +0000)
The index sets are {w,x,y,z}, {v,w,x,y,z}, and {x1,y1,z1,x2,y2,z2}

src/ck-core/ckarray.h
src/langs/jade/JArray.h
src/libs/ck-libs/paircalc/ckPairCalculator.C
src/libs/ck-libs/paircalc/ckPairCalculator.ci
src/libs/ck-libs/paircalc/pairCalculator.C
src/libs/ck-libs/paircalc/pairutil.h
src/xlat-i/xi-symbol.C

index 7516aef1e6f1973252dfe3def0c7211b64dbefa9..11239da2d66b748f561db1d33c091eefe33caedd 100644 (file)
@@ -44,17 +44,42 @@ 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(int i0) {index=i0;nInts=1;}
+       CkArrayIndex1D(int i0) {
+               index=i0;nInts=1;
+       }
 };
 class CkArrayIndex2D : public CkArrayIndex {
 public: int index[2];
-       CkArrayIndex2D(int i0,int i1) {index[0]=i0;index[1]=i1;
-               nInts=2;}
+       CkArrayIndex2D(int i0,int i1) {
+               index[0]=i0;index[1]=i1;nInts=2;
+       }
 };
 class CkArrayIndex3D : public CkArrayIndex {
 public: int index[3];
-       CkArrayIndex3D(int i0,int i1,int i2) {index[0]=i0;index[1]=i1;index[2]=i2;
-               nInts=3;}
+       CkArrayIndex3D(int i0,int i1,int i2) {
+               index[0]=i0;index[1]=i1;index[2]=i2;nInts=3;
+       }
+};
+class CkArrayIndex4D : public CkArrayIndex {
+public: short int index[4];
+       CkArrayIndex4D(){ nInts=2; }
+       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;
+       }
+};
+class CkArrayIndex5D : public CkArrayIndex {
+public: short int index[5];
+       CkArrayIndex5D(){ nInts=3; }
+       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;
+       }
+};
+class CkArrayIndex6D : public CkArrayIndex {
+public: short int index[6];
+       CkArrayIndex6D(){ nInts=3; }
+       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;
+       }
 };
 
 /** A slightly more complex array index: the key is an object
@@ -442,6 +467,12 @@ typedef struct {int x,y;} CkIndex2D;
 inline void operator|(PUP::er &p,CkIndex2D &i) {p(i.x); p(i.y);}
 typedef struct {int x,y,z;} CkIndex3D;
 inline void operator|(PUP::er &p,CkIndex3D &i) {p(i.x); p(i.y); p(i.z);}
+typedef struct {short int w,x,y,z;} CkIndex4D;
+inline void operator|(PUP::er &p,CkIndex4D &i) {p(i.w); p(i.x); p(i.y); p(i.z);}
+typedef struct {short int v,w,x,y,z;} CkIndex5D;
+inline void operator|(PUP::er &p,CkIndex5D &i) {p(i.v); p(i.w); p(i.x); p(i.y); p(i.z);}
+typedef struct {short int x1,y1,z1,x2,y2,z2;} CkIndex6D;
+inline void operator|(PUP::er &p,CkIndex6D &i) {p(i.x1); p(i.y1); p(i.z1); p(i.x2); p(i.y2); p(i.z2);}
 typedef struct {int data[CK_ARRAYINDEX_MAXLEN];} CkIndexMax;
 inline void operator|(PUP::er &p,CkIndexMax &i) {
   for (int j=0;j<CK_ARRAYINDEX_MAXLEN;j++) {
@@ -452,6 +483,9 @@ inline void operator|(PUP::er &p,CkIndexMax &i) {
 typedef ArrayElementT<CkIndex1D> ArrayElement1D;
 typedef ArrayElementT<CkIndex2D> ArrayElement2D;
 typedef ArrayElementT<CkIndex3D> ArrayElement3D;
+typedef ArrayElementT<CkIndex4D> ArrayElement4D;
+typedef ArrayElementT<CkIndex5D> ArrayElement5D;
+typedef ArrayElementT<CkIndex6D> ArrayElement6D;
 typedef ArrayElementT<CkIndexMax> ArrayElementMax;
 /*@}*/
 
index 31baf6f5f1dfe74586be3c1183bc2eac0237354a..4a568d6ee2f4e12967f0f0c0c58b90521730a03e 100644 (file)
@@ -185,6 +185,24 @@ public:
                return resize(3, d);
        }
 
+       // resize
+       JArray& resize4D(const uint d1, const uint d2, const uint d3, const uint d4){
+               uint d[] = { d1, d2, d3, d4 };
+               return resize(4, d);
+       }
+
+       // resize
+       JArray& resize5D(const uint d1, const uint d2, const uint d3, const uint d4, const uint d5){
+               uint d[] = { d1, d2, d3, d4, d5 };
+               return resize(5, d);
+       }
+
+       // resize
+       JArray& resize6D(const uint d1, const uint d2, const uint d3, const uint d4, const uint d5, const uint d6){
+               uint d[] = { d1, d2, d3, d4, d5, d6 };
+               return resize(6, d);
+       }
+
        // Get the size of the n'th dimension (1D, 2D ...)
        int getDim(const uint n) {
                assert(n>0 && n<=numDimensions);
index 6491055492e6d09baa1107b06b2e41832d63b8ba..d8d62e041f4a977c847bfffc64e7211db35d036e 100644 (file)
@@ -565,14 +565,14 @@ PairCalculator::acceptResult(int size, double *matrix)
   //original version
 #ifndef _PAIRCALC_SECONDPHASE_LOADBAL_
   if(!symmetric){
-    CkArrayIndexIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
+    CkArrayIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
     thisProxy(idx).sumPartialResult(N*grainSize, mynewData, thisIndex.z);
   }
   else {
-    CkArrayIndexIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
+    CkArrayIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
     thisProxy(idx).sumPartialResult(N*grainSize, mynewData, thisIndex.z);
     if (thisIndex.y != thisIndex.x){   // FIXME: rowNum will alway == thisIndex.x
-      CkArrayIndexIndex4D idx(thisIndex.w, 0, thisIndex.x, thisIndex.z);
+      CkArrayIndex4D idx(thisIndex.w, 0, thisIndex.x, thisIndex.z);
       thisProxy(idx).sumPartialResult(N*grainSize, othernewData, thisIndex.z);
     }
   }
@@ -586,7 +586,7 @@ PairCalculator::acceptResult(int size, double *matrix)
   if(!symmetric){    // Not right in value given!!!
     for(int segment=0;segment < segments;segment++)
       {  
-       CkArrayIndexIndex4D idx(thisIndex.w, segment*grainSize, thisIndex.y, thisIndex.z);
+       CkArrayIndex4D idx(thisIndex.w, segment*grainSize, thisIndex.y, thisIndex.z);
        partialResultMsg *msg = new (N*blocksize, 8*sizeof(int) )partialResultMsg;
        msg->N=N*blocksize;
        memcpy(msg->result,mynewData+segment*N*blocksize,msg->N*sizeof(complex));
@@ -598,7 +598,7 @@ PairCalculator::acceptResult(int size, double *matrix)
   }
   else { // else part is NOT load balanced yet!!!
 
-    CkArrayIndexIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
+    CkArrayIndex4D idx(thisIndex.w, 0, thisIndex.y, thisIndex.z);
     priorSumMsg *pmsg = new (N*grainSize, 8*sizeof(int) )priorSumMsg();
     pmsg->N=N*grainSize;
     memcpy(pmsg->result,mynewData, pmsg->N*sizeof(complex));
@@ -607,7 +607,7 @@ PairCalculator::acceptResult(int size, double *matrix)
     CkSetQueueing(pmsg, CK_QUEUEING_IFIFO); 
     thisProxy(idx).sumPartialResult(pmsg);
     if (thisIndex.y != thisIndex.x){
-      CkArrayIndexIndex4D idx(thisIndex.w, 0, thisIndex.x, thisIndex.z);
+      CkArrayIndex4D idx(thisIndex.w, 0, thisIndex.x, thisIndex.z);
       priorSumMsg *pmsg = new (N*grainSize, 8*sizeof(int) )priorSumMsg();
       pmsg->N=N*grainSize;
       memcpy(pmsg->result,othernewData, pmsg->N*sizeof(complex));
index f0729d80639c8c9c9d05a7357b93af206306badc..8d68ffac2352abf535a73259eec0c12cd77b406a 100644 (file)
@@ -13,7 +13,7 @@ module ckPairCalculator {
        };
 
 
-       array [Index4D] PairCalculator {
+       array [4D] PairCalculator {
                entry PairCalculator(bool, int, int, int, int op1, FuncType fn1, int op2, FuncType fn2, CkCallback cb, CkGroupID gid, CkArrayID final_callbackid, int final_callback_ep);
 
                entry void calculatePairs(int size, complex points[size], int, bool, bool);
index 2e9f13b78160f5d5c608a9d0515116c3ffaf50ed..a33ce70a3784d392ee785a36c26a5e68344a927b 100644 (file)
@@ -49,7 +49,7 @@ void createPairCalculator(bool sym, int s, int grainSize, int numZ, int* z, int
               for (int s1 = 0; s1 < s; s1 += grainSize) {
                   for (int s2 = s1; s2 < s; s2 += grainSize) {
                       for (int c = 0; c < blkSize; c++) {
-                          pairCalculatorProxy(CkArrayIndexIndex4D(z[numX],s1,s2,c)).
+                          pairCalculatorProxy(z[numX],s1,s2,c).
                               insert(sym, grainSize, s, blkSize, op1, f1, op2, f2, cb, pairCalcReducerProxy.ckGetGroupID(), cb_aid, cb_ep);
                           n_paircalc++;
                       }
@@ -62,7 +62,7 @@ void createPairCalculator(bool sym, int s, int grainSize, int numZ, int* z, int
               for (int s1 = 0; s1 < s; s1 += grainSize) {
                   for (int s2 = 0; s2 < s; s2 += grainSize) {
                       for (int c = 0; c < blkSize; c++) {
-                          pairCalculatorProxy(CkArrayIndexIndex4D(z[numX],s1,s2,c)).
+                          pairCalculatorProxy(z[numX],s1,s2,c).
                               insert(sym, grainSize, s, blkSize, op1, f1, op2, f2, cb, pairCalcReducerProxy.ckGetGroupID(), cb_aid, cb_ep);
                           n_paircalc++;
                           proc++;
@@ -80,7 +80,7 @@ void createPairCalculator(bool sym, int s, int grainSize, int numZ, int* z, int
               for (int s1 = 0; s1 < s; s1 += grainSize) {
                   for (int s2 = s1; s2 < s; s2 += grainSize) {
                       for (int c = 0; c < blkSize; c++) {
-                          pairCalculatorProxy(CkArrayIndexIndex4D(z[numX],s1,s2,c)).
+                          pairCalculatorProxy(z[numX],s1,s2,c).
                               insert(sym, grainSize, s, blkSize, op1, f1, op2, f2, cb, pairCalcReducerProxy.ckGetGroupID(), cb_aid, cb_ep, proc);
                           n_paircalc++;
                           proc++;
@@ -95,7 +95,7 @@ void createPairCalculator(bool sym, int s, int grainSize, int numZ, int* z, int
               for (int s1 = 0; s1 < s; s1 += grainSize) {
                   for (int s2 = 0; s2 < s; s2 += grainSize) {
                       for (int c = 0; c < blkSize; c++) {
-                          pairCalculatorProxy(CkArrayIndexIndex4D(z[numX],s1,s2,c)).
+                          pairCalculatorProxy(z[numX],s1,s2,c).
                               insert(sym, grainSize, s, blkSize, op1, f1, op2, f2, cb, pairCalcReducerProxy.ckGetGroupID(), cb_aid, cb_ep, proc);
                           n_paircalc++;
                           proc++;
@@ -135,15 +135,15 @@ void startPairCalcLeft(PairCalcID* pcid, int n, complex* ptr, int myS, int myZ){
     for (c = 0; c < blkSize; c++)
       for(s2 = 0; s2 < S; s2 += grainSize){
        if(s1 <= s2)
-         pairCalculatorProxy(CkArrayIndexIndex4D(x, s1, s2, c)).calculatePairs(n, ptr, myS, true, flag_dp);
+         pairCalculatorProxy(x, s1, s2, c).calculatePairs(n, ptr, myS, true, flag_dp);
        else
-         pairCalculatorProxy(CkArrayIndexIndex4D(x, s2, s1, c)).calculatePairs(n, ptr, myS, false, flag_dp);
+         pairCalculatorProxy(x, s2, s1, c).calculatePairs(n, ptr, myS, false, flag_dp);
       }
   }
   else {
     for (c = 0; c < blkSize; c++)
       for(s2 = 0; s2 < S; s2 += grainSize){
-       pairCalculatorProxy(CkArrayIndexIndex4D(x, s1, s2, c)).calculatePairs(n, ptr, myS, true, flag_dp);
+       pairCalculatorProxy(x, s1, s2, c).calculatePairs(n, ptr, myS, true, flag_dp);
       }
   }
 }
@@ -168,7 +168,7 @@ void startPairCalcRight(PairCalcID* pcid, int n, complex* ptr, int myS, int myZ)
   s2 = (myS/grainSize) * grainSize;
   for (c = 0; c < blkSize; c++)
     for(s1 = 0; s1 < S; s1 += grainSize){
-      pairCalculatorProxy(CkArrayIndexIndex4D(x, s1, s2, c)).calculatePairs(n, ptr, myS, false, flag_dp);
+      pairCalculatorProxy(x, s1, s2, c).calculatePairs(n, ptr, myS, false, flag_dp);
     }
 }
 
index 82b3285168e8a8f0cf7efbab052e6e695787f053..013d83a387de151a29eb7f8db60c005a611dc46a 100644 (file)
@@ -6,6 +6,7 @@
 #include "charm++.h"
 #include "ckcomplex.h"
 
+/*
 struct Index4D {unsigned short w,x,y,z;};
 
 class CkArrayIndexIndex4D: public CkArrayIndex {
@@ -19,6 +20,7 @@ class CkArrayIndexIndex4D: public CkArrayIndex {
 };
 
 typedef ArrayElementT<Index4D> ArrayElement4D;
+*/
 
 // ComplexPoint: real and imaginary components and 3 coordinates
 struct ComplexPt {
index 670888a86760c60116e43c54761759d2377b7922..9c7e2e4c8f15244d5e0b8e3cca47fa6122914f1f 100644 (file)
@@ -924,6 +924,9 @@ XStr indexSuffix2object(const XStr &indexSuffix) {
        if (indexSuffix==(const char*)"1D") return "CkIndex1D";
        if (indexSuffix==(const char*)"2D") return "CkIndex2D";
        if (indexSuffix==(const char*)"3D") return "CkIndex3D";
+       if (indexSuffix==(const char*)"4D") return "CkIndex4D";
+       if (indexSuffix==(const char*)"5D") return "CkIndex5D";
+       if (indexSuffix==(const char*)"6D") return "CkIndex6D";
        if (indexSuffix==(const char*)"Max") return "CkIndexMax";
        else return indexSuffix;
 }
@@ -1034,6 +1037,18 @@ Array::genSubDecls(XStr& str)
     str << 
     "    "<<etype<<" operator () (int i0,int i1,int i2) const \n"
     "        {return "<<etype<<"(ckGetArrayID(), CkArrayIndex3D(i0,i1,i2), CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"4D") {
+    str << 
+    "    "<<etype<<" operator () (short int i0,short int i1,short int i2,short int i3) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), CkArrayIndex4D(i0,i1,i2,i3), CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"5D") {
+    str << 
+    "    "<<etype<<" operator () (short int i0,short int i1,short int i2,short int i3,short int i4) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), CkArrayIndex5D(i0,i1,i2,i3,i4), CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"6D") {
+    str << 
+    "    "<<etype<<" operator () (short int i0,short int i1,short int i2,short int i3,short int i4,short int i5) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), CkArrayIndex6D(i0,i1,i2,i3,i4,i5), CK_DELCTOR_CALL);}\n";
     }
     str <<"    "<<ptype<<"(const CkArrayID &aid,CK_DELCTOR_PARAM) \n"
          "        :";genProxyNames(str, "",NULL, "(aid,CK_DELCTOR_ARGS)", ", ");str<<" {}\n";
@@ -1071,6 +1086,18 @@ Array::genSubDecls(XStr& str)
     str << 
     "    "<<etype<<" operator () (int idx) const \n"
     "        {return "<<etype<<"(ckGetArrayID(), *(CkArrayIndex3D*)&ckGetArrayElements()[idx], CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"4D") {
+    str << 
+    "    "<<etype<<" operator () (int idx) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), *(CkArrayIndex4D*)&ckGetArrayElements()[idx], CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"5D") {
+    str << 
+    "    "<<etype<<" operator () (int idx) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), *(CkArrayIndex5D*)&ckGetArrayElements()[idx], CK_DELCTOR_CALL);}\n";
+    } else if (indexSuffix==(const char*)"6D") {
+    str << 
+    "    "<<etype<<" operator () (int idx) const \n"
+    "        {return "<<etype<<"(ckGetArrayID(), *(CkArrayIndex6D*)&ckGetArrayElements()[idx], CK_DELCTOR_CALL);}\n";
     }
 
     str <<"    "<<ptype<<"(const CkArrayID &aid, CkArrayIndexMax *elems, int nElems, CK_DELCTOR_PARAM) \n"