Merge branch 'charm' into development
authorFilippo Gioachin <gioachin@uiuc.edu>
Fri, 5 Feb 2010 02:07:01 +0000 (20:07 -0600)
committerFilippo Gioachin <gioachin@uiuc.edu>
Fri, 5 Feb 2010 02:07:01 +0000 (20:07 -0600)
44 files changed:
doc/charm++/entry.tex
doc/charm++/python.tex
examples/charm++/cell/md/main.C
examples/charm++/cell/md/md_config.h
examples/charm++/cell/md/pairCompute.C
examples/charm++/cell/md/pairCompute.ci
examples/charm++/cell/md/pairCompute.h
examples/charm++/cell/md/patch.C
examples/charm++/cell/md/patch.ci
examples/charm++/cell/md/patch.h
examples/charm++/cell/md/selfCompute.C
examples/charm++/cell/md/selfCompute.ci
examples/charm++/cell/md/selfCompute.h
src/arch/net-linux-x86_64/conv-mach.h
src/ck-core/charm++.h
src/ck-core/charm.h
src/ck-core/ck.C
src/ck-core/ckarray.C
src/ck-core/ckarray.h
src/ck-core/cklocation.C
src/ck-core/cklocation.h
src/ck-core/envelope.h
src/ck-core/init.C
src/ck-core/msgalloc.C
src/ck-cp/controlPoints.C
src/ck-cp/controlPoints.h
src/ck-perf/trace-controlPoints.C
src/ck-perf/trace-controlPoints.h
src/conv-core/global-elfgot.C
src/libs/ck-libs/ParFUM-Iterators/Makefile
src/libs/ck-libs/ParFUM-Iterators/ParFUM_Iterators.cc
src/libs/ck-libs/ParFUM-Iterators/ParFUM_Iterators.h
src/libs/ck-libs/ampi/ampi.C
src/libs/ck-libs/ampi/ampif.C
src/libs/ck-libs/ampi/ampiimpl.h
src/libs/ck-libs/tcharm/tcharm.C
src/util/simd.h
tests/ampi/Makefile
tests/ampi/migration/Makefile [new file with mode: 0644]
tests/ampi/migration/test.C [new file with mode: 0644]
tests/charm++/megatest/Make.depends
tests/charm++/megatest/Makefile
tests/charm++/megatest/inlineem.C [new file with mode: 0644]
tests/charm++/megatest/inlineem.ci [new file with mode: 0644]

index dc5fcb480b8dffe3f4f894f24e57d46fd537915a..fd16eaf092613a1ca079405c00bba9a9b0b77f40 100644 (file)
@@ -114,6 +114,6 @@ a pointer.
 \index{python}\item[python] entry methods are methods which are enabled to be
 called from python scripts running as explained in section~\ref{python}. In
 order to work, the object owning the method must also be declared with the
-keywork \kw{python}.
+keyword \kw{python}.
 
 \end{description}
index 9757f0880db54c42fa10fdb546209091d655c06a..defad4afeb7c69253134fd5a0fc851550c2d83e0 100644 (file)
@@ -119,7 +119,7 @@ later in this subsection).
 
 \item[high level]
 In order to have the ability to call high level \charmpp{} functions (available
-through the keywork \kw{python}) this flag must be set to true. If it is false,
+through the keyword \kw{python}) this flag must be set to true. If it is false,
 the entire module ``charm'' will not be present, but the startup of the script
 will be faster.
 
index 5a99b3631ad1e462c8b1ac11e59c189be3f6dd41..1384684babc7a37056f66175b5e01182cb66b5da 100644 (file)
@@ -76,7 +76,12 @@ Main::Main(CkArgMsg* msg) {
            numStepsRemaining,
            STEPS_PER_PRINT
          );
-
+  if(sizeof(MD_FLOAT)==4)
+    CkPrintf("Single Precision\n");
+  else  if(sizeof(MD_FLOAT)==8)
+    CkPrintf("Double Precision\n");
+  else 
+    CkPrintf("Precision %d bytes\n",sizeof(MD_FLOAT));
   // DMK - DEBUG
   #if ENABLE_USER_EVENTS != 0
     traceRegisterUserEvent("Patch::forceCheckIn_callback()", PROJ_USER_EVENT_PATCH_FORCECHECKIN_CALLBACK);
@@ -144,7 +149,7 @@ Main::Main(CkArgMsg* msg) {
     int numPairComputes = 0;
     for (int i = 0; i < numPEs; i++) { numPairComputes += peStats[i]; }
     for (int i = 0; i < numPEs; i++) {
-      CkPrintf("[STATS] :: peStats[%d] = %6d (%5.2f%%)\n", i, peStats[i], ((float)peStats[i]) / ((float)numPairComputes) * 100.0f);
+      CkPrintf("[STATS] :: peStats[%d] = %6d (%5.2f%%)\n", i, peStats[i], ((float)peStats[i]) / ((float)numPairComputes) * 10zero);
     }
   #endif
 
index ca6521fff8337c5268240c99512eeef87779490d..c5b13c8a0e2a5fd1692b5d8bf0e0dc3077a65d15 100644 (file)
@@ -5,6 +5,45 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Default Simulation Parameters
 
+
+// convenience typedefs and consts to facilitate float vs double usage
+#define USE_DOUBLE 0
+#if USE_DOUBLE
+typedef double  MD_FLOAT;
+#define  MD_VEC veclf
+const double zero=0.0;
+const double one=1.0;
+const double two=2.0;
+#define myvec_numElems veclf_numElems;
+#define vextract_MDF vextractlf
+#define vsub_MDF vsublf
+#define vadd_MDF vaddlf
+#define vmadd_MDF vmaddlf
+#define vmul_MDF vmullf
+#define vspread_MDF vspreadlf
+#define vrecip_MDF vreciplf
+#define vsqrt_MDF vsqrtlf
+#define visfinite_MDF visfinitelf
+#else
+typedef float  MD_FLOAT;
+#define  MD_VEC vecf
+#define myvec_numElems vecf_numElems;
+const float zero=0.0f;
+const float one=1.0f;
+const float two=2.0f;
+
+#define vextract_MDF vextractf
+#define vsub_MDF vsubf
+#define vadd_MDF vaddf
+#define vmadd_MDF vmaddf
+#define vmul_MDF vmulf
+#define vspread_MDF vspreadf
+#define vrecip_MDF vrecipf
+#define vsqrt_MDF vsqrtf
+#define visfinite_MDF visfinitef
+#endif
+
+
 #define DEFAULT_NUM_PARTICLES_PER_PATCH  (128)
 
 #define DEFAULT_NUM_PATCHES_X              (2)
 ////////////////////////////////////////////////////////////////////////////////
 // Physics Constants
 
+#if USE_DOUBLE
+#define TIME_PER_STEP       (1.0e-15)           // Unit: s
+#define SIM_BOX_SIDE_LEN    (1.0e-7)            // Unit: m (NOTE: 1 nm = 10A)
+#define COULOMBS_CONSTANT   (8.987551787e-9)    // Unit: N*(m^2)*(C^-2)
+#define ELECTRON_CHARGE     (-1.602176487e-19)  // Unit: C
+#define ELECTRON_MASS       (9.109382154e-31)   // Unit: kg
+#else
 #define TIME_PER_STEP       (1.0e-15f)           // Unit: s
 #define SIM_BOX_SIDE_LEN    (1.0e-7f)            // Unit: m (NOTE: 1 nm = 10A)
 #define COULOMBS_CONSTANT   (8.987551787e-9f)    // Unit: N*(m^2)*(C^-2)
 #define ELECTRON_CHARGE     (-1.602176487e-19f)  // Unit: C
 #define ELECTRON_MASS       (9.109382154e-31f)   // Unit: kg
-
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Misc. Helper Macros
@@ -50,6 +96,9 @@
 // DMK - DEBUG
 #define COUNT_FLOPS                      (0)
 
+// EJB - SANITY CHECK
+#define SANITY_CHECK                     (0)
+
 // DMK - DEBUG
 #define ENABLE_USER_EVENTS               (0)
 #define PROJ_USER_EVENT_PATCH_FORCECHECKIN_CALLBACK  (1120)
index 903681e7412c36c0fd286f0910a1852a1c938522..662f20c9417dc56157087f52f2d7e06aae2fe836 100644 (file)
@@ -47,21 +47,21 @@ void PairCompute::init(int numParticlesPerPatch) {
   // Initialize the arrays
   numParticles = numParticlesPerPatch;
   #if USE_PROXY_PATCHES == 0
-    particleX[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleX[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleY[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleY[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleZ[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleZ[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleQ[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleQ[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+    particleX[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleX[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleY[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleY[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleZ[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleZ[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleQ[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleQ[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
   #endif
-  forceX[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceX[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceY[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceY[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceZ[0] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceZ[1] = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+  forceX[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceX[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceY[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceY[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceZ[0] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceZ[1] = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
   patchDataCount = 0;
 
   // Check in with the main chare
@@ -69,14 +69,14 @@ void PairCompute::init(int numParticlesPerPatch) {
 }
 
 
-void PairCompute::patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, int fromPatch, CProxy_ProxyPatch proxyPatchProxy) {
+void PairCompute::patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, int fromPatch, CProxy_ProxyPatch proxyPatchProxy) {
   #if USE_PROXY_PATCHES != 0
     this->proxyPatchProxy[fromPatch] = proxyPatchProxy;
   #endif
   patchData(numParticles, particleX, particleY, particleZ, particleQ, fromPatch);
 }
 
-void PairCompute::patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, int fromPatch) {
+void PairCompute::patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, int fromPatch) {
 
   // Copy the data from the parameters
   #if USE_PROXY_PATCHES != 0
@@ -85,10 +85,10 @@ void PairCompute::patchData(int numParticles, float* particleX, float* particleY
     this->particleZ[fromPatch] = particleZ;
     this->particleQ[fromPatch] = particleQ;
   #else
-    memcpy(this->particleX[fromPatch], particleX, numParticles * sizeof(float));
-    memcpy(this->particleY[fromPatch], particleY, numParticles * sizeof(float));
-    memcpy(this->particleZ[fromPatch], particleZ, numParticles * sizeof(float));
-    memcpy(this->particleQ[fromPatch], particleQ, numParticles * sizeof(float));
+    memcpy(this->particleX[fromPatch], particleX, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleY[fromPatch], particleY, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleZ[fromPatch], particleZ, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleQ[fromPatch], particleQ, numParticles * sizeof(MD_FLOAT));
   #endif
 
   // Increment the patch count and initiate the calculation of both patches have
index 3b414390955d607682c63e255f00d290da627b97..0d60813b23b7798549634c50d4827ea340111ef9 100644 (file)
@@ -10,30 +10,30 @@ module pairCompute {
     entry void init(int numParticlesPerPatch);
 
     entry void patchData(int numParticles,
-                         float particleX[numParticles],
-                         float particleY[numParticles],
-                         float particleZ[numParticles],
-                         float particleQ[numParticles],
+                         MD_FLOAT particleX[numParticles],
+                         MD_FLOAT particleY[numParticles],
+                         MD_FLOAT particleZ[numParticles],
+                         MD_FLOAT particleQ[numParticles],
                          int fromPatch
                         );
 
     entry [accel] void doCalc()[  readonly : int numParticles <impl_obj->numParticles>,
                                   readonly : int thisIndex_x <impl_obj->thisIndex.x>,
                                   readonly : int thisIndex_y <impl_obj->thisIndex.y>,
-                                  readonly : float p0_x[numParticles] <impl_obj->particleX[0]>,
-                                  readonly : float p1_x[numParticles] <impl_obj->particleX[1]>,
-                                  readonly : float p0_y[numParticles] <impl_obj->particleY[0]>,
-                                  readonly : float p1_y[numParticles] <impl_obj->particleY[1]>,
-                                  readonly : float p0_z[numParticles] <impl_obj->particleZ[0]>,
-                                  readonly : float p1_z[numParticles] <impl_obj->particleZ[1]>,
-                                  readonly : float p0_q[numParticles] <impl_obj->particleQ[0]>,
-                                  readonly : float p1_q[numParticles] <impl_obj->particleQ[1]>,
-                                 writeonly : float f0_x[numParticles] <impl_obj->forceX[0]>,
-                                 writeonly : float f1_x[numParticles] <impl_obj->forceX[1]>,
-                                 writeonly : float f0_y[numParticles] <impl_obj->forceY[0]>,
-                                 writeonly : float f1_y[numParticles] <impl_obj->forceY[1]>,
-                                 writeonly : float f0_z[numParticles] <impl_obj->forceZ[0]>,
-                                 writeonly : float f1_z[numParticles] <impl_obj->forceZ[1]>,
+                                  readonly : MD_FLOAT p0_x[numParticles] <impl_obj->particleX[0]>,
+                                  readonly : MD_FLOAT p1_x[numParticles] <impl_obj->particleX[1]>,
+                                  readonly : MD_FLOAT p0_y[numParticles] <impl_obj->particleY[0]>,
+                                  readonly : MD_FLOAT p1_y[numParticles] <impl_obj->particleY[1]>,
+                                  readonly : MD_FLOAT p0_z[numParticles] <impl_obj->particleZ[0]>,
+                                  readonly : MD_FLOAT p1_z[numParticles] <impl_obj->particleZ[1]>,
+                                  readonly : MD_FLOAT p0_q[numParticles] <impl_obj->particleQ[0]>,
+                                  readonly : MD_FLOAT p1_q[numParticles] <impl_obj->particleQ[1]>,
+                                 writeonly : MD_FLOAT f0_x[numParticles] <impl_obj->forceX[0]>,
+                                 writeonly : MD_FLOAT f1_x[numParticles] <impl_obj->forceX[1]>,
+                                 writeonly : MD_FLOAT f0_y[numParticles] <impl_obj->forceY[0]>,
+                                 writeonly : MD_FLOAT f1_y[numParticles] <impl_obj->forceY[1]>,
+                                 writeonly : MD_FLOAT f0_z[numParticles] <impl_obj->forceZ[0]>,
+                                 writeonly : MD_FLOAT f1_z[numParticles] <impl_obj->forceZ[1]>,
                                  writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                ] {
 
@@ -51,20 +51,20 @@ module pairCompute {
         localFlopCount = 0;
       #endif
 
-      register vecf* p1_x_vec = (vecf*)p1_x;
-      register vecf* p1_y_vec = (vecf*)p1_y;
-      register vecf* p1_z_vec = (vecf*)p1_z;
-      register vecf* p1_q_vec = (vecf*)p1_q;
-      register vecf* f1_x_vec = (vecf*)f1_x;
-      register vecf* f1_y_vec = (vecf*)f1_y;
-      register vecf* f1_z_vec = (vecf*)f1_z;
+      register MD_VEC* p1_x_vec = (MD_VEC*)p1_x;
+      register MD_VEC* p1_y_vec = (MD_VEC*)p1_y;
+      register MD_VEC* p1_z_vec = (MD_VEC*)p1_z;
+      register MD_VEC* p1_q_vec = (MD_VEC*)p1_q;
+      register MD_VEC* f1_x_vec = (MD_VEC*)f1_x;
+      register MD_VEC* f1_y_vec = (MD_VEC*)f1_y;
+      register MD_VEC* f1_z_vec = (MD_VEC*)f1_z;
       register int i;
       register int j;
-      register const int numParticlesByVecSize = numParticles / vecf_numElems;
+      register const int numParticlesByVecSize = numParticles / myvec_numElems;
 
       // Zero out the force array for p1 (p0's force array will be zero'ed for each
       //   particle in the outer loop)
-      vecf zero_vec = vspreadf(0.0f);
+      MD_VEC zero_vec = vspread_MDF(zero);
       for (j = 0; j < numParticlesByVecSize; j++) {
         f1_x_vec[j] = zero_vec;
         f1_y_vec[j] = zero_vec;
@@ -72,19 +72,19 @@ module pairCompute {
       }
 
       // Spread coulumb's constant across a vector
-      vecf coulomb_vec = vspreadf(COULOMBS_CONSTANT);
+      MD_VEC coulomb_vec = vspread_MDF(COULOMBS_CONSTANT);
 
       // Outer-loop (p0)
       for (i = 0; i < numParticles; i++) {
 
         // Spread this particle's values out over vectors
-        vecf p0_x_i_vec = vspreadf(p0_x[i]);
-        vecf p0_y_i_vec = vspreadf(p0_y[i]);
-        vecf p0_z_i_vec = vspreadf(p0_z[i]);
-        vecf p0_q_i_vec = vspreadf(p0_q[i]);
-        vecf f0_x_i_vec = vspreadf(0.0f);
-        vecf f0_y_i_vec = vspreadf(0.0f);
-        vecf f0_z_i_vec = vspreadf(0.0f);
+        MD_VEC p0_x_i_vec = vspread_MDF(p0_x[i]);
+        MD_VEC p0_y_i_vec = vspread_MDF(p0_y[i]);
+        MD_VEC p0_z_i_vec = vspread_MDF(p0_z[i]);
+        MD_VEC p0_q_i_vec = vspread_MDF(p0_q[i]);
+        MD_VEC f0_x_i_vec = vspread_MDF(zero);
+        MD_VEC f0_y_i_vec = vspread_MDF(zero);
+        MD_VEC f0_z_i_vec = vspread_MDF(zero);
 
         #if 1
 
@@ -97,22 +97,21 @@ module pairCompute {
         /// Loop Preamble ///
 
         const int loopUpper = numParticlesByVecSize - 3;
-
         // Setup Input for Stage 2 - Initially for j+2
         const int jPlus2 = 2;
-        vecf p1_x_j_vec = p1_x_vec[jPlus2];
-        vecf p1_y_j_vec = p1_y_vec[jPlus2];
-        vecf p1_z_j_vec = p1_z_vec[jPlus2];
-        vecf p1_q_j_vec = p1_q_vec[jPlus2];
+        MD_VEC p1_x_j_vec = p1_x_vec[jPlus2];
+        MD_VEC p1_y_j_vec = p1_y_vec[jPlus2];
+        MD_VEC p1_z_j_vec = p1_z_vec[jPlus2];
+        MD_VEC p1_q_j_vec = p1_q_vec[jPlus2];
 
         // Setup Input for Stage 3 - Initial for j+1
         const int jPlus1 = 1;
-        vecf p_x_diff_vec = p0_x_i_vec - p1_x_vec[jPlus1];
-        vecf p_y_diff_vec = p0_y_i_vec - p1_y_vec[jPlus1];
-        vecf p_z_diff_vec = p0_z_i_vec - p1_z_vec[jPlus1];
-        vecf p1_q_j_vec_s2 = p1_q_vec[jPlus1];
-        vecf r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
-        vecf r_vec = vsqrtf(r_2_vec);
+        MD_VEC p_x_diff_vec = p0_x_i_vec - p1_x_vec[jPlus1];
+        MD_VEC p_y_diff_vec = p0_y_i_vec - p1_y_vec[jPlus1];
+        MD_VEC p_z_diff_vec = p0_z_i_vec - p1_z_vec[jPlus1];
+        MD_VEC p1_q_j_vec_s2 = p1_q_vec[jPlus1];
+        MD_VEC r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
+        MD_VEC r_vec = vsqrt_MDF(r_2_vec);
 
         // DMK - DEBUG
         #if COUNT_FLOPS != 0
@@ -121,21 +120,21 @@ module pairCompute {
 
         // Setup Input for Stage 4 - Initially for j+0
         const int jPlus0 = 0;
-        vecf f_x_vec;
-        vecf f_y_vec;
-        vecf f_z_vec;
+        MD_VEC f_x_vec;
+        MD_VEC f_y_vec;
+        MD_VEC f_z_vec;
         {
-          vecf p_x_diff_vec = p0_x_i_vec - p1_x_vec[jPlus0];
-          vecf p_y_diff_vec = p0_y_i_vec - p1_y_vec[jPlus0];
-          vecf p_z_diff_vec = p0_z_i_vec - p1_z_vec[jPlus0];
-          vecf r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
-          vecf r_vec = vsqrtf(r_2_vec);
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
-          vecf f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_vec[jPlus0]) * r_2_recip_vec);
+          MD_VEC p_x_diff_vec = p0_x_i_vec - p1_x_vec[jPlus0];
+          MD_VEC p_y_diff_vec = p0_y_i_vec - p1_y_vec[jPlus0];
+          MD_VEC p_z_diff_vec = p0_z_i_vec - p1_z_vec[jPlus0];
+          MD_VEC r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
+          MD_VEC r_vec = vsqrt_MDF(r_2_vec);
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          MD_VEC f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_vec[jPlus0]) * r_2_recip_vec);
           f_x_vec = p_x_diff_norm_vec * f_mag_vec;
           f_y_vec = p_y_diff_norm_vec * f_mag_vec;
           f_z_vec = p_z_diff_norm_vec * f_mag_vec;
@@ -153,31 +152,31 @@ module pairCompute {
           #if 1
 
           // Stage 4 - Apply force vector
-          f0_x_i_vec = vaddf(f0_x_i_vec, f_x_vec);
-          f0_y_i_vec = vaddf(f0_y_i_vec, f_y_vec);
-          f0_z_i_vec = vaddf(f0_z_i_vec, f_z_vec);
-          f1_x_vec[j] = vsubf(f1_x_vec[j], f_x_vec);
-          f1_y_vec[j] = vsubf(f1_y_vec[j], f_y_vec);
-          f1_z_vec[j] = vsubf(f1_z_vec[j], f_z_vec);
+          f0_x_i_vec = vadd_MDF(f0_x_i_vec, f_x_vec);
+          f0_y_i_vec = vadd_MDF(f0_y_i_vec, f_y_vec);
+          f0_z_i_vec = vadd_MDF(f0_z_i_vec, f_z_vec);
+          f1_x_vec[j] = vsub_MDF(f1_x_vec[j], f_x_vec);
+          f1_y_vec[j] = vsub_MDF(f1_y_vec[j], f_y_vec);
+          f1_z_vec[j] = vsub_MDF(f1_z_vec[j], f_z_vec);
 
           // Stage 3 - Calculate force vector
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_z_diff_norm_vec = vmulf(p_z_diff_vec, r_recip_vec);
-          vecf p_y_diff_norm_vec = vmulf(p_y_diff_vec, r_recip_vec);
-          vecf p_x_diff_norm_vec = vmulf(p_x_diff_vec, r_recip_vec);
-          vecf f_mag_vec = vmulf(vmulf(coulomb_vec, p0_q_i_vec), vmulf(p1_q_j_vec_s2, r_2_recip_vec));
-          f_x_vec = vmulf(p_x_diff_norm_vec, f_mag_vec);
-          f_y_vec = vmulf(p_y_diff_norm_vec, f_mag_vec);
-          f_z_vec = vmulf(p_z_diff_norm_vec, f_mag_vec);
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+          MD_VEC p_z_diff_norm_vec = vmul_MDF(p_z_diff_vec, r_recip_vec);
+          MD_VEC p_y_diff_norm_vec = vmul_MDF(p_y_diff_vec, r_recip_vec);
+          MD_VEC p_x_diff_norm_vec = vmul_MDF(p_x_diff_vec, r_recip_vec);
+          MD_VEC f_mag_vec = vmul_MDF(vmul_MDF(coulomb_vec, p0_q_i_vec), vmul_MDF(p1_q_j_vec_s2, r_2_recip_vec));
+          f_x_vec = vmul_MDF(p_x_diff_norm_vec, f_mag_vec);
+          f_y_vec = vmul_MDF(p_y_diff_norm_vec, f_mag_vec);
+          f_z_vec = vmul_MDF(p_z_diff_norm_vec, f_mag_vec);
 
           // Stage 2 - Calculate radius
           p1_q_j_vec_s2 = p1_q_j_vec;
-          p_x_diff_vec = vsubf(p0_x_i_vec, p1_x_j_vec);
-          p_y_diff_vec = vsubf(p0_y_i_vec, p1_y_j_vec);
-          p_z_diff_vec = vsubf(p0_z_i_vec, p1_z_j_vec);
-          r_2_vec = vmaddf(p_x_diff_vec, p_x_diff_vec, vmaddf(p_y_diff_vec, p_y_diff_vec, vmulf(p_z_diff_vec, p_z_diff_vec)));
-          r_vec = vsqrtf(r_2_vec);
+          p_x_diff_vec = vsub_MDF(p0_x_i_vec, p1_x_j_vec);
+          p_y_diff_vec = vsub_MDF(p0_y_i_vec, p1_y_j_vec);
+          p_z_diff_vec = vsub_MDF(p0_z_i_vec, p1_z_j_vec);
+          r_2_vec = vmadd_MDF(p_x_diff_vec, p_x_diff_vec, vmadd_MDF(p_y_diff_vec, p_y_diff_vec, vmul_MDF(p_z_diff_vec, p_z_diff_vec)));
+          r_vec = vsqrt_MDF(r_2_vec);
 
           // Stage 1 - Load particle data
           const int jIndexToLoad = j + 3;
@@ -197,12 +196,12 @@ module pairCompute {
           f1_z_vec[j] -= f_z_vec;
 
           // Stage 3 - Calculate force vector
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
-          vecf f_mag_vec = coulomb_vec * p0_q_i_vec * p1_q_j_vec_s2 * r_2_recip_vec;  // Calc force magnitude
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          MD_VEC f_mag_vec = coulomb_vec * p0_q_i_vec * p1_q_j_vec_s2 * r_2_recip_vec;  // Calc force magnitude
           f_x_vec = p_x_diff_norm_vec * f_mag_vec;  // Multiply normalized vector by force magnitude
           f_y_vec = p_y_diff_norm_vec * f_mag_vec;
           f_z_vec = p_z_diff_norm_vec * f_mag_vec;
@@ -213,7 +212,7 @@ module pairCompute {
           p_y_diff_vec = p0_y_i_vec - p1_y_j_vec;
           p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
           r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
-          r_vec = vsqrtf(r_2_vec);
+          r_vec = vsqrt_MDF(r_2_vec);
 
           // Stage 1 - Load particle data
           const int jIndexToLoad = j + 3;
@@ -249,15 +248,15 @@ module pairCompute {
 
         // Complete Calc for Stage 2 Data - Calculate Force Vector, Apply Force Vector
         {
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
-          vecf f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec_s2) * r_2_recip_vec);
-          vecf f_x_vec = p_x_diff_norm_vec * f_mag_vec;
-          vecf f_y_vec = p_y_diff_norm_vec * f_mag_vec;
-          vecf f_z_vec = p_z_diff_norm_vec * f_mag_vec;
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          MD_VEC f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec_s2) * r_2_recip_vec);
+          MD_VEC f_x_vec = p_x_diff_norm_vec * f_mag_vec;
+          MD_VEC f_y_vec = p_y_diff_norm_vec * f_mag_vec;
+          MD_VEC f_z_vec = p_z_diff_norm_vec * f_mag_vec;
           f0_x_i_vec += f_x_vec;
           f0_y_i_vec += f_y_vec;
           f0_z_i_vec += f_z_vec;
@@ -273,20 +272,20 @@ module pairCompute {
 
         // Complete Calc for Stage 1 Data - Calculate Radius, Calculate Force Vector, Apply Force Vector
         {
-          vecf p_x_diff_vec = p0_x_i_vec - p1_x_j_vec;
-          vecf p_y_diff_vec = p0_y_i_vec - p1_y_j_vec;
-          vecf p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
-          vecf r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
-          vecf r_vec = vsqrtf(r_2_vec);
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
-          vecf f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) * r_2_recip_vec);
-          vecf f_x_vec = p_x_diff_norm_vec * f_mag_vec;
-          vecf f_y_vec = p_y_diff_norm_vec * f_mag_vec;
-          vecf f_z_vec = p_z_diff_norm_vec * f_mag_vec;
+          MD_VEC p_x_diff_vec = p0_x_i_vec - p1_x_j_vec;
+          MD_VEC p_y_diff_vec = p0_y_i_vec - p1_y_j_vec;
+          MD_VEC p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
+          MD_VEC r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
+          MD_VEC r_vec = vsqrt_MDF(r_2_vec);
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          MD_VEC f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) * r_2_recip_vec);
+          MD_VEC f_x_vec = p_x_diff_norm_vec * f_mag_vec;
+          MD_VEC f_y_vec = p_y_diff_norm_vec * f_mag_vec;
+          MD_VEC f_z_vec = p_z_diff_norm_vec * f_mag_vec;
           f0_x_i_vec += f_x_vec;
           f0_y_i_vec += f_y_vec;
           f0_z_i_vec += f_z_vec;
@@ -306,36 +305,36 @@ module pairCompute {
         for (j = 0; j < numParticlesByVecSize; j++) {
 
           // Load the particles' data
-          vecf p1_x_j_vec = p1_x_vec[j];
-          vecf p1_y_j_vec = p1_y_vec[j];
-          vecf p1_z_j_vec = p1_z_vec[j];
-          vecf p1_q_j_vec = p1_q_vec[j];
+          MD_VEC p1_x_j_vec = p1_x_vec[j];
+          MD_VEC p1_y_j_vec = p1_y_vec[j];
+          MD_VEC p1_z_j_vec = p1_z_vec[j];
+          MD_VEC p1_q_j_vec = p1_q_vec[j];
 
           // Calculate the vector between the particles
-          vecf p_x_diff_vec = p0_x_i_vec - p1_x_j_vec;
-          vecf p_y_diff_vec = p0_y_i_vec - p1_y_j_vec;
-          vecf p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
+          MD_VEC p_x_diff_vec = p0_x_i_vec - p1_x_j_vec;
+          MD_VEC p_y_diff_vec = p0_y_i_vec - p1_y_j_vec;
+          MD_VEC p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
 
           // Calculate r and r^2 between the particles
-          vecf p_x_diff_2_vec = p_x_diff_vec * p_x_diff_vec;
-          vecf p_y_diff_2_vec = p_y_diff_vec * p_y_diff_vec;
-          vecf p_z_diff_2_vec = p_z_diff_vec * p_z_diff_vec;
-          vecf r_2_vec = p_x_diff_2_vec + p_y_diff_2_vec + p_z_diff_2_vec;
-          vecf r_vec = vsqrtf(r_2_vec);
+          MD_VEC p_x_diff_2_vec = p_x_diff_vec * p_x_diff_vec;
+          MD_VEC p_y_diff_2_vec = p_y_diff_vec * p_y_diff_vec;
+          MD_VEC p_z_diff_2_vec = p_z_diff_vec * p_z_diff_vec;
+          MD_VEC r_2_vec = p_x_diff_2_vec + p_y_diff_2_vec + p_z_diff_2_vec;
+          MD_VEC r_vec = vsqrt_MDF(r_2_vec);
 
           // Normalize the vector between the particles
-          vecf p_x_diff_norm_vec = p_x_diff_vec / r_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec / r_vec;
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec / r_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec / r_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec / r_vec;
 
           // Calculate the magnitude of the electrostatic force between the particles
-          vecf f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) / r_2_vec);
+          MD_VEC f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) / r_2_vec);
 
           // Multiply the magnitude by the normalized postition difference vector to
           //   create the force vector
-          vecf f_x_vec = p_x_diff_norm_vec * f_mag_vec;
-          vecf f_y_vec = p_y_diff_norm_vec * f_mag_vec;
-          vecf f_z_vec = p_z_diff_norm_vec * f_mag_vec;
+          MD_VEC f_x_vec = p_x_diff_norm_vec * f_mag_vec;
+          MD_VEC f_y_vec = p_y_diff_norm_vec * f_mag_vec;
+          MD_VEC f_z_vec = p_z_diff_norm_vec * f_mag_vec;
 
           // Add the force to the outer-loop particle and subtract it from the inner-loop particles
           f0_x_i_vec += f_x_vec;
@@ -353,11 +352,23 @@ module pairCompute {
         }
 
         #endif
-
         // Write force values for the outer-loop particle back to memory
-        f0_x[i] = vextractf(f0_x_i_vec, 0) + vextractf(f0_x_i_vec, 1) + vextractf(f0_x_i_vec, 2) + vextractf(f0_x_i_vec, 3);
-        f0_y[i] = vextractf(f0_y_i_vec, 0) + vextractf(f0_y_i_vec, 1) + vextractf(f0_y_i_vec, 2) + vextractf(f0_y_i_vec, 3);
-        f0_z[i] = vextractf(f0_z_i_vec, 0) + vextractf(f0_z_i_vec, 1) + vextractf(f0_z_i_vec, 2) + vextractf(f0_z_i_vec, 3);
+#ifdef USE_DOUBLE
+        f0_x[i] = vextract_MDF(f0_x_i_vec, 0) + vextract_MDF(f0_x_i_vec, 1);
+        f0_y[i] = vextract_MDF(f0_y_i_vec, 0) + vextract_MDF(f0_y_i_vec, 1);
+        f0_z[i] = vextract_MDF(f0_z_i_vec, 0) + vextract_MDF(f0_z_i_vec, 1);
+#else
+
+        f0_x[i] = vextract_MDF(f0_x_i_vec, 0) + vextract_MDF(f0_x_i_vec, 1) + vextract_MDF(f0_x_i_vec, 2) + vextract_MDF(f0_x_i_vec, 3);
+        f0_y[i] = vextract_MDF(f0_y_i_vec, 0) + vextract_MDF(f0_y_i_vec, 1) + vextract_MDF(f0_y_i_vec, 2) + vextract_MDF(f0_y_i_vec, 3);
+        f0_z[i] = vextract_MDF(f0_z_i_vec, 0) + vextract_MDF(f0_z_i_vec, 1) + vextract_MDF(f0_z_i_vec, 2) + vextract_MDF(f0_z_i_vec, 3);
+#endif
+#if SANITY_CHECK
+       CkAssert(finite(f0_x[i]));
+       CkAssert(finite(f0_y[i]));
+       CkAssert(finite(f0_z[i]));
+
+#endif 
       }
 
       // DMK - DEBUG
@@ -369,7 +380,7 @@ module pairCompute {
           CkPrintf("[DEBUG] :: PairCompute[%d,%d]::doCalc() - Took %lf ms to execute... numParticles:%d\n"
                    "             p0[0] = { %e, %e, %e : %e }, p1[0] = { %e, %e, %e : %e }...\n"
                    "             f0[0] = { %e, %e, %e }, f1[0] = { %e, %e, %e }...\n",
-                   thisIndex_x, thisIndex_y, deltaTime * 1000.0f, numParticles,
+                   thisIndex_x, thisIndex_y, deltaTime * 100zero, numParticles,
                    p0_x[0], p0_y[0], p0_z[0], p0_q[0], p1_x[0], p1_y[0], p1_z[0], p1_q[0],
                    f0_x[0], f0_y[0], f0_z[0], f1_x[0], f1_y[0], f1_z[0]
                   );
index b6f3729640b08354d16a0e10d8da67f473ee1885..0dc8371dff54fb8c97e59b25a05da8fc03d6240c 100644 (file)
@@ -19,15 +19,15 @@ class PairCompute : public CBase_PairCompute {
     int patchDataCount;
 
     /// Particle Buffers ///
-    float* particleX[2];
-    float* particleY[2];
-    float* particleZ[2];
-    float* particleQ[2];
+    MD_FLOAT* particleX[2];
+    MD_FLOAT* particleY[2];
+    MD_FLOAT* particleZ[2];
+    MD_FLOAT* particleQ[2];
 
     /// Force Buffers ///
-    float* forceX[2];
-    float* forceY[2];
-    float* forceZ[2];
+    MD_FLOAT* forceX[2];
+    MD_FLOAT* forceY[2];
+    MD_FLOAT* forceZ[2];
 
     #if USE_PROXY_PATCHES != 0
       CProxy_ProxyPatch proxyPatchProxy[2];
@@ -45,8 +45,8 @@ class PairCompute : public CBase_PairCompute {
 
     /// Entry Methods ///
     void init(int numParticlesPerPatch);
-    void patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, int fromPatch, CProxy_ProxyPatch proxyPatchProxy);
-    void patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, int fromPatch);
+    void patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, int fromPatch, CProxy_ProxyPatch proxyPatchProxy);
+    void patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, int fromPatch);
     void doCalc_callback();
 
 };
index 195d7a8ecd25dfd17fae6be9c6d774ebb1ffa2a6..97fa43e8a53bddc5da9c9229421281267fea31e5 100644 (file)
@@ -8,14 +8,14 @@ void Patch::randomizeParticles() {
 
   // Fill in a box with electrons that initially have no velocity
   for (int i = 0; i < numParticles; i++) {
-    particleX[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / 2.0f);
-    particleY[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / 2.0f);
-    particleZ[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / 2.0f);
+    particleX[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / two);
+    particleY[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / two);
+    particleZ[i] = (randf() * SIM_BOX_SIDE_LEN) - (SIM_BOX_SIDE_LEN / two);
     particleQ[i] = ELECTRON_CHARGE;
     particleM[i] = ELECTRON_MASS;
-    velocityX[i] = 0.0f;
-    velocityY[i] = 0.0f;
-    velocityZ[i] = 0.0f;
+    velocityX[i] = zero;
+    velocityY[i] = zero;
+    velocityZ[i] = zero;
 
     // DMK - DEBUG
     #if DUMP_INITIAL_PARTICLE_DATA != 0
@@ -26,13 +26,24 @@ void Patch::randomizeParticles() {
                velocityX[i], velocityY[i], velocityZ[i]
               );
     #endif
+      //EJB DEBUG
+    #if SANITY_CHECK
+      CkAssert(finite(particleX[i]));
+      CkAssert(finite(particleY[i]));
+      CkAssert(finite(particleZ[i]));
+      CkAssert(finite(velocityX[i]));
+      CkAssert(finite(velocityY[i]));
+      CkAssert(finite(velocityZ[i]));
+    #endif 
+
   }
 }
 
 
-float Patch::randf() {
+MD_FLOAT Patch::randf() {
   const int mask = 0x7FFFFFFF;
-  return (((float)(rand() % mask)) / ((float)(mask)));
+  return (((MD_FLOAT)(rand() % mask)) / ((MD_FLOAT)(mask)));
+
 }
 
 
@@ -81,17 +92,17 @@ void Patch::init_common(int numParticles) {
 
   // Allocate memory for the particles
   this->numParticles = numParticles;
-  particleX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleQ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleM = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  velocityX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  velocityY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  velocityZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+  particleX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleQ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleM = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  velocityX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  velocityY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  velocityZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
 
   // Initialize the particles
   randomizeParticles();
@@ -138,15 +149,15 @@ void Patch::startIteration_common(int numIters) {
 
   // Clear the force sum arrays
   #if 1
-    memset(forceSumX, 0, sizeof(float) * numParticles);
-    memset(forceSumY, 0, sizeof(float) * numParticles);
-    memset(forceSumZ, 0, sizeof(float) * numParticles);
+    memset(forceSumX, 0, sizeof(MD_FLOAT) * numParticles);
+    memset(forceSumY, 0, sizeof(MD_FLOAT) * numParticles);
+    memset(forceSumZ, 0, sizeof(MD_FLOAT) * numParticles);
   #else
-    register vecf* fsx = (vecf*)forceSumX;
-    register vecf* fsy = (vecf*)forceSumY;
-    register vecf* fsz = (vecf*)forceSumZ;
-    const vecf zero_vec = vspreadf(0.0f);
-    register const int numParticles_vec = numParticles / vecf_numElems;
+    register MD_VEC* fsx = (MD_VEC*)forceSumX;
+    register MD_VEC* fsy = (MD_VEC*)forceSumY;
+    register MD_VEC* fsz = (MD_VEC*)forceSumZ;
+    const MD_VEC zero_vec = vspread_MDF(zero);
+    register const int numParticles_vec = numParticles / myvec_numElems;
     for (int i = 0; i < numParticles_vec; i++) {
       fsx[i] = zero_vec;
       fsy[i] = zero_vec;
@@ -200,28 +211,33 @@ void Patch::startIteration_common(int numIters) {
 }
 
 
-void Patch::forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ) {
+void Patch::forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ) {
   forceCheckIn(numParticles, forceX, forceY, forceZ, 1);
 }
-void Patch::forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ, int numForceCheckIns) {
+void Patch::forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ, int numForceCheckIns) {
 
   // Accumulate the force data
   #if 0
-    register vecf* fsx = (vecf*)forceSumX;
-    register vecf* fsy = (vecf*)forceSumY;
-    register vecf* fsz = (vecf*)forceSumZ;
-    register vecf* fx = (vecf*)forceX;
-    register vecf* fy = (vecf*)forceY;
-    register vecf* fz = (vecf*)forceZ;
-    register const int numParticles_vec = numParticles / vecf_numElems;
+    register MD_VEC* fsx = (MD_VEC*)forceSumX;
+    register MD_VEC* fsy = (MD_VEC*)forceSumY;
+    register MD_VEC* fsz = (MD_VEC*)forceSumZ;
+    register MD_VEC* fx = (MD_VEC*)forceX;
+    register MD_VEC* fy = (MD_VEC*)forceY;
+    register MD_VEC* fz = (MD_VEC*)forceZ;
+    register const int numParticles_vec = numParticles / myvec_numElems;
     register int i;
     for (i = 0; i < numParticles_vec; i++) {
-      fsx[i] = vaddf(fsx[i], fx[i]);
-      fsy[i] = vaddf(fsy[i], fy[i]);
-      fsz[i] = vaddf(fsz[i], fz[i]);
+      fsx[i] = vadd_MDF(fsx[i], fx[i]);
+      fsy[i] = vadd_MDF(fsy[i], fy[i]);
+      fsz[i] = vadd_MDF(fsz[i], fz[i]);
     }
   #else
     for (int i = 0; i < numParticles; i++) {
+#if SANITY_CHECK
+      CkAssert(finite(forceX[i]));
+      CkAssert(finite(forceY[i]));
+      CkAssert(finite(forceZ[i]));
+#endif 
       forceSumX[i] += forceX[i];
       forceSumY[i] += forceY[i];
       forceSumZ[i] += forceZ[i];
@@ -300,31 +316,31 @@ void ProxyPatch::init(int numParticles) {
 
   // Allocate memory for the particles
   this->numParticles = numParticles;
-  particleX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  particleQ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceSumZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+  particleX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  particleQ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceSumZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
 
   // Check in with the main proxy
   mainProxy.initCheckIn();
 }
 
 
-void ProxyPatch::patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ) {
+void ProxyPatch::patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ) {
 
   // Copy in the updated particle data
-  memcpy(this->particleX, particleX, numParticles * sizeof(float));
-  memcpy(this->particleY, particleY, numParticles * sizeof(float));
-  memcpy(this->particleZ, particleZ, numParticles * sizeof(float));
-  memcpy(this->particleQ, particleQ, numParticles * sizeof(float));
+  memcpy(this->particleX, particleX, numParticles * sizeof(MD_FLOAT));
+  memcpy(this->particleY, particleY, numParticles * sizeof(MD_FLOAT));
+  memcpy(this->particleZ, particleZ, numParticles * sizeof(MD_FLOAT));
+  memcpy(this->particleQ, particleQ, numParticles * sizeof(MD_FLOAT));
 
   // Clear out the force arrays
-  memset(this->forceSumX, 0, numParticles * sizeof(float));
-  memset(this->forceSumY, 0, numParticles * sizeof(float));
-  memset(this->forceSumZ, 0, numParticles * sizeof(float));
+  memset(this->forceSumX, 0, numParticles * sizeof(MD_FLOAT));
+  memset(this->forceSumY, 0, numParticles * sizeof(MD_FLOAT));
+  memset(this->forceSumZ, 0, numParticles * sizeof(MD_FLOAT));
 
   // Reset the patch checkin counters
   checkInCount = 0;
@@ -361,17 +377,17 @@ void ProxyPatch::patchData(int numParticles, float* particleX, float* particleY,
 }
 
 
-void ProxyPatch::forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ) {
+void ProxyPatch::forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ) {
 
   // Accumulate the force data
   #if USE_PROXY_PATCHES != 0  // Calls will be local and pointers will be aligned, so take advantage and vectorize the code
-    register vecf* forceX_vec = (vecf*)forceX;
-    register vecf* forceY_vec = (vecf*)forceY;
-    register vecf* forceZ_vec = (vecf*)forceZ;
-    register vecf* forceSumX_vec = (vecf*)forceSumX;
-    register vecf* forceSumY_vec = (vecf*)forceSumY;
-    register vecf* forceSumZ_vec = (vecf*)forceSumZ;
-    const int numParticles_vec = numParticles / vecf_numElems;
+    register MD_VEC* forceX_vec = (MD_VEC*)forceX;
+    register MD_VEC* forceY_vec = (MD_VEC*)forceY;
+    register MD_VEC* forceZ_vec = (MD_VEC*)forceZ;
+    register MD_VEC* forceSumX_vec = (MD_VEC*)forceSumX;
+    register MD_VEC* forceSumY_vec = (MD_VEC*)forceSumY;
+    register MD_VEC* forceSumZ_vec = (MD_VEC*)forceSumZ;
+    const int numParticles_vec = numParticles / myvec_numElems;
     for (int i = 0; i < numParticles_vec; i++) {
       forceSumX_vec[i] += forceX_vec[i];
       forceSumY_vec[i] += forceY_vec[i];
index 5b23bf45c40db73703b737643a3be8ccf79f3a48..4ac7d72918c32c30b94a54e0db438a4048118652 100644 (file)
@@ -5,21 +5,21 @@ module patch {
   accelblock {
 
     void accumForce(int numParticles,
-                    float* forceSumX, float* forceSumY, float* forceSumZ,
-                    float* forceX, float* forceY, float* forceZ
+                    MD_FLOAT* forceSumX, MD_FLOAT* forceSumY, MD_FLOAT* forceSumZ,
+                    MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ
                    ) {
-      register vecf* fsx = (vecf*)forceSumX;
-      register vecf* fsy = (vecf*)forceSumY;
-      register vecf* fsz = (vecf*)forceSumZ;
-      register vecf* fx = (vecf*)forceX;
-      register vecf* fy = (vecf*)forceY;
-      register vecf* fz = (vecf*)forceZ;
-      register const int numParticles_vec = numParticles / vecf_numElems;
+      register MD_VEC* fsx = (MD_VEC*)forceSumX;
+      register MD_VEC* fsy = (MD_VEC*)forceSumY;
+      register MD_VEC* fsz = (MD_VEC*)forceSumZ;
+      register MD_VEC* fx = (MD_VEC*)forceX;
+      register MD_VEC* fy = (MD_VEC*)forceY;
+      register MD_VEC* fz = (MD_VEC*)forceZ;
+      register const int numParticles_vec = numParticles / myvec_numElems;
       register int i;
       for (i = 0; i < numParticles_vec; i++) {
-        fsx[i] = vaddf(fsx[i], fx[i]);
-        fsy[i] = vaddf(fsy[i], fy[i]);
-        fsz[i] = vaddf(fsz[i], fz[i]);
+        fsx[i] = vadd_MDF(fsx[i], fx[i]);
+        fsy[i] = vadd_MDF(fsy[i], fy[i]);
+        fsz[i] = vadd_MDF(fsz[i], fz[i]);
       }
     }
   };
@@ -31,16 +31,16 @@ module patch {
     entry void init(int numParticles);
 
     entry void patchData(int numParticles,
-                         float particleX[numParticles],
-                         float particleY[numParticles],
-                         float particleZ[numParticles],
-                         float particleQ[numParticles]
+                         MD_FLOAT particleX[numParticles],
+                         MD_FLOAT particleY[numParticles],
+                         MD_FLOAT particleZ[numParticles],
+                         MD_FLOAT particleQ[numParticles]
                         );
 
     entry void forceCheckIn(int numParticles,
-                            float forceX[numParticles],
-                            float forceY[numParticles],
-                            float forceZ[numParticles]
+                            MD_FLOAT forceX[numParticles],
+                            MD_FLOAT forceY[numParticles],
+                            MD_FLOAT forceZ[numParticles]
                            );
   };
 
@@ -55,14 +55,14 @@ module patch {
     entry void startIterations(int numIters);
 
     entry void forceCheckIn(int numParticles,
-                            float forceX[numParticles],
-                            float forceY[numParticles],
-                            float forceZ[numParticles]
+                            MD_FLOAT forceX[numParticles],
+                            MD_FLOAT forceY[numParticles],
+                            MD_FLOAT forceZ[numParticles]
                            );
     entry void forceCheckIn(int numParticles,
-                            float forceX[numParticles],
-                            float forceY[numParticles],
-                            float forceZ[numParticles],
+                            MD_FLOAT forceX[numParticles],
+                            MD_FLOAT forceY[numParticles],
+                            MD_FLOAT forceZ[numParticles],
                             int numForceCheckIns
                            );
 
@@ -70,16 +70,16 @@ module patch {
                                     readonly : int thisIndex_x <impl_obj->thisIndex.x>,
                                     readonly : int thisIndex_y <impl_obj->thisIndex.y>,
                                     readonly : int thisIndex_z <impl_obj->thisIndex.z>,
-                                   readwrite : float p_x[numParticles] <impl_obj->particleX>,
-                                   readwrite : float p_y[numParticles] <impl_obj->particleY>,
-                                   readwrite : float p_z[numParticles] <impl_obj->particleZ>,
-                                    readonly : float p_m[numParticles] <impl_obj->particleM>,
-                                    readonly : float f_x[numParticles] <impl_obj->forceSumX>,
-                                    readonly : float f_y[numParticles] <impl_obj->forceSumY>,
-                                    readonly : float f_z[numParticles] <impl_obj->forceSumZ>,
-                                   readwrite : float v_x[numParticles] <impl_obj->velocityX>,
-                                   readwrite : float v_y[numParticles] <impl_obj->velocityY>,
-                                   readwrite : float v_z[numParticles] <impl_obj->velocityZ>,
+                                   readwrite : MD_FLOAT p_x[numParticles] <impl_obj->particleX>,
+                                   readwrite : MD_FLOAT p_y[numParticles] <impl_obj->particleY>,
+                                   readwrite : MD_FLOAT p_z[numParticles] <impl_obj->particleZ>,
+                                    readonly : MD_FLOAT p_m[numParticles] <impl_obj->particleM>,
+                                    readonly : MD_FLOAT f_x[numParticles] <impl_obj->forceSumX>,
+                                    readonly : MD_FLOAT f_y[numParticles] <impl_obj->forceSumY>,
+                                    readonly : MD_FLOAT f_z[numParticles] <impl_obj->forceSumZ>,
+                                   readwrite : MD_FLOAT v_x[numParticles] <impl_obj->velocityX>,
+                                   readwrite : MD_FLOAT v_y[numParticles] <impl_obj->velocityY>,
+                                   readwrite : MD_FLOAT v_z[numParticles] <impl_obj->velocityZ>,
                                    writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                   ] {
 
@@ -88,28 +88,28 @@ module patch {
         localFlopCount = 0;
       #endif
 
-      register vecf* p_x_vec = (vecf*)p_x;
-      register vecf* p_y_vec = (vecf*)p_y;
-      register vecf* p_z_vec = (vecf*)p_z;
-      register vecf* p_m_vec = (vecf*)p_m;
-      register vecf* f_x_vec = (vecf*)f_x;
-      register vecf* f_y_vec = (vecf*)f_y;
-      register vecf* f_z_vec = (vecf*)f_z;
-      register vecf* v_x_vec = (vecf*)v_x;
-      register vecf* v_y_vec = (vecf*)v_y;
-      register vecf* v_z_vec = (vecf*)v_z;
+      register MD_VEC* p_x_vec = (MD_VEC*)p_x;
+      register MD_VEC* p_y_vec = (MD_VEC*)p_y;
+      register MD_VEC* p_z_vec = (MD_VEC*)p_z;
+      register MD_VEC* p_m_vec = (MD_VEC*)p_m;
+      register MD_VEC* f_x_vec = (MD_VEC*)f_x;
+      register MD_VEC* f_y_vec = (MD_VEC*)f_y;
+      register MD_VEC* f_z_vec = (MD_VEC*)f_z;
+      register MD_VEC* v_x_vec = (MD_VEC*)v_x;
+      register MD_VEC* v_y_vec = (MD_VEC*)v_y;
+      register MD_VEC* v_z_vec = (MD_VEC*)v_z;
       register int i;
-      register const int numParticles_vec = numParticles / vecf_numElems;
+      register const int numParticles_vec = numParticles / myvec_numElems;
 
-      vecf delta_time_vec = vspreadf(TIME_PER_STEP);
+      MD_VEC delta_time_vec = vspread_MDF(TIME_PER_STEP);
 
       // Add the acceleration to the velocity and add the update velocity to the position
       for (i = 0; i < numParticles_vec; i++) {
 
         // Update the velocity : v_new = v_old + (F/m)dt
-        vecf new_v_x_vec = v_x_vec[i] + (delta_time_vec * (f_x_vec[i] / p_m_vec[i]));
-        vecf new_v_y_vec = v_y_vec[i] + (delta_time_vec * (f_y_vec[i] / p_m_vec[i]));
-        vecf new_v_z_vec = v_z_vec[i] + (delta_time_vec * (f_z_vec[i] / p_m_vec[i]));
+        MD_VEC new_v_x_vec = v_x_vec[i] + (delta_time_vec * (f_x_vec[i] / p_m_vec[i]));
+        MD_VEC new_v_y_vec = v_y_vec[i] + (delta_time_vec * (f_y_vec[i] / p_m_vec[i]));
+        MD_VEC new_v_z_vec = v_z_vec[i] + (delta_time_vec * (f_z_vec[i] / p_m_vec[i]));
         v_x_vec[i] = new_v_x_vec;
         v_y_vec[i] = new_v_y_vec;
         v_z_vec[i] = new_v_z_vec;
index eb8ed11028bc30397ffc3e31f001fba78b846958..71f982456a862a20652e9fb2644d235aad858f53 100644 (file)
@@ -20,17 +20,17 @@ class Patch : public CBase_Patch {
     int remainingIterations;
 
     int numParticles;
-    float* particleX;  // x-coordinate
-    float* particleY;  // y-coordinate
-    float* particleZ;  // z-coordinate
-    float* particleQ;  // charge
-    float* particleM;  // mass
-    float* velocityX;  // velocity x-component
-    float* velocityY;  // velocity y-component
-    float* velocityZ;  // velocity z-component
-    float* forceSumX;  // Buffer to sum of force x components from computes
-    float* forceSumY;  // Buffer to sum of force y components from computes
-    float* forceSumZ;  // Buffer to sum of force z components from computes
+    MD_FLOAT* particleX;  // x-coordinate
+    MD_FLOAT* particleY;  // y-coordinate
+    MD_FLOAT* particleZ;  // z-coordinate
+    MD_FLOAT* particleQ;  // charge
+    MD_FLOAT* particleM;  // mass
+    MD_FLOAT* velocityX;  // velocity x-component
+    MD_FLOAT* velocityY;  // velocity y-component
+    MD_FLOAT* velocityZ;  // velocity z-component
+    MD_FLOAT* forceSumX;  // Buffer to sum of force x components from computes
+    MD_FLOAT* forceSumY;  // Buffer to sum of force y components from computes
+    MD_FLOAT* forceSumZ;  // Buffer to sum of force z components from computes
 
     #if USE_ARRAY_SECTIONS != 0
       CProxySection_PairCompute pairComputeArraySection_lower;
@@ -49,7 +49,7 @@ class Patch : public CBase_Patch {
 
     /// Member Functions ///
     void randomizeParticles();
-    float randf();
+    MD_FLOAT randf();
     void startIteration_common(int numIters);
 
   public:
@@ -65,8 +65,8 @@ class Patch : public CBase_Patch {
     void init_common(int numParticles);
     void startIteration();
     void startIterations(int numIters);
-    void forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ);
-    void forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ, int numForceCheckIns);
+    void forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ);
+    void forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ, int numForceCheckIns);
     void integrate_callback();
 
 };
@@ -82,13 +82,13 @@ class ProxyPatch : public CBase_ProxyPatch {
 
     /// Member Variables ///
     int numParticles;
-    float* particleX;
-    float* particleY;
-    float* particleZ;
-    float* particleQ;
-    float* forceSumX;
-    float* forceSumY;
-    float* forceSumZ;
+    MD_FLOAT* particleX;
+    MD_FLOAT* particleY;
+    MD_FLOAT* particleZ;
+    MD_FLOAT* particleQ;
+    MD_FLOAT* forceSumX;
+    MD_FLOAT* forceSumY;
+    MD_FLOAT* forceSumZ;
 
     int patchIndex;
 
@@ -104,8 +104,8 @@ class ProxyPatch : public CBase_ProxyPatch {
 
     /// Entry Methods ///
     void init(int numParticles);
-    void patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ);
-    void forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ);
+    void patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ);
+    void forceCheckIn(int numParticles, MD_FLOAT* forceX, MD_FLOAT* forceY, MD_FLOAT* forceZ);
 
 };
 
index 8322638d29f6d83c70d0a246bbc1631bf6deef6e..950396ae6cf04bf21fe308ab6df60afb7b1ef34c 100644 (file)
@@ -38,28 +38,28 @@ void SelfCompute::init(int numParticlesPerPatch) {
   // Allocate buffers for force data
   numParticles = numParticlesPerPatch;
   #if USE_PROXY_PATCHES == 0
-    particleX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-    particleQ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+    particleX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+    particleQ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
   #endif
-  forceX = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceY = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
-  forceZ = (float*)(CmiMallocAligned(numParticles * sizeof(float), 128));
+  forceX = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceY = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
+  forceZ = (MD_FLOAT*)(CmiMallocAligned(numParticles * sizeof(MD_FLOAT), 128));
 
   // Check in with the main chare
   mainProxy.initCheckIn();
 }
 
 
-void SelfCompute::patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, CProxy_ProxyPatch proxyPatchProxy) {
+void SelfCompute::patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, CProxy_ProxyPatch proxyPatchProxy) {
   #if USE_PROXY_PATCHES != 0
     this->proxyPatchProxy = proxyPatchProxy;
   #endif
   patchData(numParticles, particleX, particleY, particleZ, particleQ);
 }
 
-void SelfCompute::patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ) {
+void SelfCompute::patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ) {
 
   // Copy the data from the parameters
   #if USE_PROXY_PATCHES != 0
@@ -68,10 +68,10 @@ void SelfCompute::patchData(int numParticles, float* particleX, float* particleY
     this->particleZ = particleZ;
     this->particleQ = particleQ;
   #else
-    memcpy(this->particleX, particleX, numParticles * sizeof(float));
-    memcpy(this->particleY, particleY, numParticles * sizeof(float));
-    memcpy(this->particleZ, particleZ, numParticles * sizeof(float));
-    memcpy(this->particleQ, particleQ, numParticles * sizeof(float));
+    memcpy(this->particleX, particleX, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleY, particleY, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleZ, particleZ, numParticles * sizeof(MD_FLOAT));
+    memcpy(this->particleQ, particleQ, numParticles * sizeof(MD_FLOAT));
   #endif
 
   // Initiate the calculation for this compute
index e0c30d60f2195ee5564e51ece4131ea1f0626bff..5cb62ba2c85ecb82fe7b9d89690a4157772e4cbe 100644 (file)
@@ -10,23 +10,23 @@ module selfCompute {
     entry void init(int numParticlesPerPatch);
 
     entry void patchData(int numParticles,
-                         float particleX[numParticles],
-                         float particleY[numParticles],
-                         float particleZ[numParticles],
-                         float particleQ[numParticles]
+                         MD_FLOAT particleX[numParticles],
+                         MD_FLOAT particleY[numParticles],
+                         MD_FLOAT particleZ[numParticles],
+                         MD_FLOAT particleQ[numParticles]
                         );
 
     entry [accel] void doCalc()[
                                  readonly : int numParticles <impl_obj->numParticles>,
                                  readonly : int thisIndex_x <impl_obj->thisIndex.x>,
                                  readonly : int thisIndex_y <impl_obj->thisIndex.y>,
-                                 readonly : float particleX[numParticles] <impl_obj->particleX>,
-                                 readonly : float particleY[numParticles] <impl_obj->particleY>,
-                                 readonly : float particleZ[numParticles] <impl_obj->particleZ>,
-                                 readonly : float particleQ[numParticles] <impl_obj->particleQ>,
-                                writeonly : float f0_x[numParticles] <impl_obj->forceX>,
-                                writeonly : float f0_y[numParticles] <impl_obj->forceY>,
-                                writeonly : float f0_z[numParticles] <impl_obj->forceZ>,
+                                 readonly : MD_FLOAT particleX[numParticles] <impl_obj->particleX>,
+                                 readonly : MD_FLOAT particleY[numParticles] <impl_obj->particleY>,
+                                 readonly : MD_FLOAT particleZ[numParticles] <impl_obj->particleZ>,
+                                 readonly : MD_FLOAT particleQ[numParticles] <impl_obj->particleQ>,
+                                writeonly : MD_FLOAT f0_x[numParticles] <impl_obj->forceX>,
+                                writeonly : MD_FLOAT f0_y[numParticles] <impl_obj->forceY>,
+                                writeonly : MD_FLOAT f0_z[numParticles] <impl_obj->forceZ>,
                                 writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                ] {
 
@@ -42,20 +42,22 @@ module selfCompute {
       #if COUNT_FLOPS != 0
         localFlopCount = 0;
       #endif
-
-      register vecf* p0_x_vec = (vecf*)particleX;
-      register vecf* p0_y_vec = (vecf*)particleY;
-      register vecf* p0_z_vec = (vecf*)particleZ;
-      register vecf* p0_q_vec = (vecf*)particleQ;
-      register vecf* f0_x_vec = (vecf*)f0_x;
-      register vecf* f0_y_vec = (vecf*)f0_y;
-      register vecf* f0_z_vec = (vecf*)f0_z;
+      const int vec_numElems= myvec_numElems;
+      const int VEC_MASK= vec_numElems-1;
+      const int shifter= sizeof(MD_FLOAT)==4 ? 2 :1;
+      register MD_VEC* p0_x_vec = (MD_VEC*)particleX;
+      register MD_VEC* p0_y_vec = (MD_VEC*)particleY;
+      register MD_VEC* p0_z_vec = (MD_VEC*)particleZ;
+      register MD_VEC* p0_q_vec = (MD_VEC*)particleQ;
+      register MD_VEC* f0_x_vec = (MD_VEC*)f0_x;
+      register MD_VEC* f0_y_vec = (MD_VEC*)f0_y;
+      register MD_VEC* f0_z_vec = (MD_VEC*)f0_z;
       register int i;
       register int j;
-      register const int numParticlesByVecSize = numParticles / vecf_numElems;
+      register const int numParticlesByVecSize = numParticles / myvec_numElems;
 
       // Zero out the force output
-      vecf zero_vec = vspreadf(0.0f);
+      MD_VEC zero_vec = vspread_MDF(zero);
       for (j = 0; j < numParticlesByVecSize; j++) {
         f0_x_vec[j] = zero_vec;
         f0_y_vec[j] = zero_vec;
@@ -63,30 +65,30 @@ module selfCompute {
       }
 
       // Spread coulumb's constant across a vector
-      vecf coulomb_vec = vspreadf(COULOMBS_CONSTANT);
+      MD_VEC coulomb_vec = vspread_MDF(COULOMBS_CONSTANT);
 
       // Outer-loop
       for (i = 0; i < numParticles; i++) {
 
         // Interact with all particles (one-by-one) until the vector boundary
-        for (j = i + 1; ((j & 0x3) != 0x0) && (j < numParticles); j++) {
+        for (j = i + 1; ((j & VEC_MASK) != 0x0) && (j < numParticles); j++) {
 
-          float p_x_diff = particleX[i] - particleX[j];
-          float p_y_diff = particleY[i] - particleY[j];
-          float p_z_diff = particleZ[i] - particleZ[j];
-          float r_2 = (p_x_diff * p_x_diff) + (p_y_diff * p_y_diff) + (p_z_diff * p_z_diff);
-          float r = sqrt(r_2);
+          MD_FLOAT p_x_diff = particleX[i] - particleX[j];
+          MD_FLOAT p_y_diff = particleY[i] - particleY[j];
+          MD_FLOAT p_z_diff = particleZ[i] - particleZ[j];
+          MD_FLOAT r_2 = (p_x_diff * p_x_diff) + (p_y_diff * p_y_diff) + (p_z_diff * p_z_diff);
+          MD_FLOAT r = sqrt(r_2);
 
-          float p_x_diff_norm = p_x_diff / r;
-          float p_y_diff_norm = p_y_diff / r;
-          float p_z_diff_norm = p_z_diff / r;
+          MD_FLOAT p_x_diff_norm = p_x_diff / r;
+          MD_FLOAT p_y_diff_norm = p_y_diff / r;
+          MD_FLOAT p_z_diff_norm = p_z_diff / r;
 
-          float p_q_prod = particleQ[i] * particleQ[j];
-          float f_mag = COULOMBS_CONSTANT * (p_q_prod / r_2);
+          MD_FLOAT p_q_prod = particleQ[i] * particleQ[j];
+          MD_FLOAT f_mag = COULOMBS_CONSTANT * (p_q_prod / r_2);
 
-          float f_x = f_mag * p_x_diff_norm;
-          float f_y = f_mag * p_y_diff_norm;
-          float f_z = f_mag * p_z_diff_norm;
+          MD_FLOAT f_x = f_mag * p_x_diff_norm;
+          MD_FLOAT f_y = f_mag * p_y_diff_norm;
+          MD_FLOAT f_z = f_mag * p_z_diff_norm;
 
           f0_x[i] += f_x;
           f0_y[i] += f_y;
@@ -102,45 +104,55 @@ module selfCompute {
         }
 
         // Spread this particle's (p0[i]) values out over vectors
-        vecf p0_x_i_vec = vspreadf(particleX[i]);
-        vecf p0_y_i_vec = vspreadf(particleY[i]);
-        vecf p0_z_i_vec = vspreadf(particleZ[i]);
-        vecf p0_q_i_vec = vspreadf(particleQ[i]);
-        vecf f0_x_i_vec = vspreadf(0.0f);
-        vecf f0_y_i_vec = vspreadf(0.0f);
-        vecf f0_z_i_vec = vspreadf(0.0f);
+        MD_VEC p0_x_i_vec = vspread_MDF(particleX[i]);
+        MD_VEC p0_y_i_vec = vspread_MDF(particleY[i]);
+        MD_VEC p0_z_i_vec = vspread_MDF(particleZ[i]);
+        MD_VEC p0_q_i_vec = vspread_MDF(particleQ[i]);
+        MD_VEC f0_x_i_vec = vspread_MDF(zero);
+        MD_VEC f0_y_i_vec = vspread_MDF(zero);
+        MD_VEC f0_z_i_vec = vspread_MDF(zero);
 
         // Switch to vectorized loop for the remaining elements in the particle array
-        for (j = j >> 2; j < numParticlesByVecSize; j++) {
+       
+        for (j = j >>shifter; j < numParticlesByVecSize; j++) {
 
           // Load the particles' data
-          vecf p0_x_j_vec = p0_x_vec[j];
-          vecf p0_y_j_vec = p0_y_vec[j];
-          vecf p0_z_j_vec = p0_z_vec[j];
-          vecf p0_q_j_vec = p0_q_vec[j];
+          MD_VEC p0_x_j_vec = p0_x_vec[j];
+          MD_VEC p0_y_j_vec = p0_y_vec[j];
+          MD_VEC p0_z_j_vec = p0_z_vec[j];
+          MD_VEC p0_q_j_vec = p0_q_vec[j];
 
           // Calculate the vector between the particles
-          vecf p_x_diff_vec = p0_x_i_vec - p0_x_j_vec;
-          vecf p_y_diff_vec = p0_y_i_vec - p0_y_j_vec;
-          vecf p_z_diff_vec = p0_z_i_vec - p0_z_j_vec;
-
+          MD_VEC p_x_diff_vec = p0_x_i_vec - p0_x_j_vec;
+          MD_VEC p_y_diff_vec = p0_y_i_vec - p0_y_j_vec;
+          MD_VEC p_z_diff_vec = p0_z_i_vec - p0_z_j_vec;
           // Calculate r and r^2 between the particles
-          vecf r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
-          vecf r_vec = vsqrtf(r_2_vec);
+          MD_VEC r_2_vec = (p_x_diff_vec * p_x_diff_vec) + (p_y_diff_vec * p_y_diff_vec) + (p_z_diff_vec * p_z_diff_vec);
+          MD_VEC r_vec = vsqrt_MDF(r_2_vec);
 
           // Normalize the vector between the particles
-          vecf r_recip_vec = vrecipf(r_vec);
-          vecf r_2_recip_vec = vrecipf(r_2_vec);
-          vecf p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
-          vecf p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
-          vecf p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
-          vecf f_mag_vec = coulomb_vec * p0_q_i_vec * p0_q_j_vec * r_2_recip_vec;  // Calc force magnitude
+          MD_VEC r_recip_vec = vrecip_MDF(r_vec);
+          MD_VEC r_2_recip_vec = vrecip_MDF(r_2_vec);
+#if SANITY_CHECK
+         CkAssert(visfinite_MDF(r_2_vec));
+         CkAssert(visfinite_MDF(r_vec));
+#endif
+//             CkAssert(&p0_x_vec !=);
+/*
+       { // how the hell does this not flake out?
+               CkPrintf("i %d j %d px_i %+6e px_j %+6e py_i %+6e py_j %+6e pz_i %+6e pz_j%+6e\n",i,j,vextract_MDF(p0_x_i_vec,0),vextract_MDF(p0_x_j_vec,0),vextract_MDF(p0_y_i_vec,0),vextract_MDF(p0_y_j_vec,0),vextract_MDF(p0_z_i_vec,0),vextract_MDF(p0_z_j_vec,0));
+       }
+*/
+          MD_VEC p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          MD_VEC p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          MD_VEC p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          MD_VEC f_mag_vec = coulomb_vec * p0_q_i_vec * p0_q_j_vec * r_2_recip_vec;  // Calc force magnitude
 
           // Multiply the magnitude by the normalized postition difference vector to
           //   create the force vector
-          vecf f_x_vec = p_x_diff_norm_vec * f_mag_vec;
-          vecf f_y_vec = p_y_diff_norm_vec * f_mag_vec;
-          vecf f_z_vec = p_z_diff_norm_vec * f_mag_vec;
+          MD_VEC f_x_vec = p_x_diff_norm_vec * f_mag_vec;
+          MD_VEC f_y_vec = p_y_diff_norm_vec * f_mag_vec;
+          MD_VEC f_z_vec = p_z_diff_norm_vec * f_mag_vec;
 
           // Add the force to the outer-loop particle and subtract it from the inner-loop particles
           f0_x_i_vec += f_x_vec;
@@ -157,9 +169,9 @@ module selfCompute {
         }
 
         // Add force values for p0[i] into f0
-        f0_x[i] += vextractf(f0_x_i_vec, 0) + vextractf(f0_x_i_vec, 1) + vextractf(f0_x_i_vec, 2) + vextractf(f0_x_i_vec, 3);
-        f0_y[i] += vextractf(f0_y_i_vec, 0) + vextractf(f0_y_i_vec, 1) + vextractf(f0_y_i_vec, 2) + vextractf(f0_y_i_vec, 3);
-        f0_z[i] += vextractf(f0_z_i_vec, 0) + vextractf(f0_z_i_vec, 1) + vextractf(f0_z_i_vec, 2) + vextractf(f0_z_i_vec, 3);
+        f0_x[i] += vextract_MDF(f0_x_i_vec, 0) + vextract_MDF(f0_x_i_vec, 1) + vextract_MDF(f0_x_i_vec, 2) + vextract_MDF(f0_x_i_vec, 3);
+        f0_y[i] += vextract_MDF(f0_y_i_vec, 0) + vextract_MDF(f0_y_i_vec, 1) + vextract_MDF(f0_y_i_vec, 2) + vextract_MDF(f0_y_i_vec, 3);
+        f0_z[i] += vextract_MDF(f0_z_i_vec, 0) + vextract_MDF(f0_z_i_vec, 1) + vextract_MDF(f0_z_i_vec, 2) + vextract_MDF(f0_z_i_vec, 3);
       }
 
       // DMK - DEBUG
index bea380921b69010e21cbee0ea639a7c4fa7e5926..2da8fbbda7ad9ba78f1aa0c597219e6db65773d8 100644 (file)
@@ -17,13 +17,13 @@ class SelfCompute : public CBase_SelfCompute {
 
     /// Member Variables ///
     int numParticles;
-    float* particleX;
-    float* particleY;
-    float* particleZ;
-    float* particleQ;
-    float* forceX;
-    float* forceY;
-    float* forceZ;
+    MD_FLOAT* particleX;
+    MD_FLOAT* particleY;
+    MD_FLOAT* particleZ;
+    MD_FLOAT* particleQ;
+    MD_FLOAT* forceX;
+    MD_FLOAT* forceY;
+    MD_FLOAT* forceZ;
 
     CProxy_ProxyPatch proxyPatchProxy;
 
@@ -41,8 +41,8 @@ class SelfCompute : public CBase_SelfCompute {
 
     /// Entry Methods ///
     void init(int numParticlesPerPatch);
-    void patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ, CProxy_ProxyPatch proxyPatchProxy);
-    void patchData(int numParticles, float* particleX, float* particleY, float* particleZ, float* particleQ);
+    void patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ, CProxy_ProxyPatch proxyPatchProxy);
+    void patchData(int numParticles, MD_FLOAT* particleX, MD_FLOAT* particleY, MD_FLOAT* particleZ, MD_FLOAT* particleQ);
     void doCalc_callback();
 
 };
index d07d6ebf22a38ff2558629c0df17e73dfc49ef0e..50bb8e366bf9e2ed6bd23d53d26d60918f261e3b 100644 (file)
@@ -42,8 +42,8 @@
 #define CMK_THREADS_ARE_WIN32_FIBERS                       0
 
 #define CMK_SIGNAL_NOT_NEEDED                              0
-#define CMK_SIGNAL_USE_SIGACTION                           1
-#define CMK_SIGNAL_USE_SIGACTION_WITH_RESTART              0
+#define CMK_SIGNAL_USE_SIGACTION                           0
+#define CMK_SIGNAL_USE_SIGACTION_WITH_RESTART              1
 
 #define CMK_THREADS_REQUIRE_NO_CPV                         0
 #define CMK_THREADS_COPY_STACK                             0
index 8dab92637db6e2d0d69445c592476a31907c37e2..1e4fe06133af67442f987e2e7dfc73a78eaaaeb1 100644 (file)
@@ -101,9 +101,10 @@ class CkEntryOptions : public CkNoncopyable {
        typedef unsigned int prio_t; //Datatype used to represent priorities
        prio_t *prioPtr; //Points to message priority values
        prio_t prioStore; //For short priorities, stores the priority value
+       CkGroupID  depGroupID;  // group dependence
 public:
        CkEntryOptions(void): queueingtype(CK_QUEUEING_FIFO), prioBits(0), 
-                              prioPtr(NULL), prioStore(0) {}
+                              prioPtr(NULL), prioStore(0) { depGroupID.setZero(); }
 
        ~CkEntryOptions() {
                if ( prioPtr != NULL && queueingtype != CK_QUEUEING_IFIFO ) {
@@ -152,11 +153,13 @@ public:
        }
        
        inline void setQueueing(int queueingtype_) {queueingtype=queueingtype_;}
+       inline void setGroupDepID(CkGroupID &gid) { depGroupID = gid; }
 
        ///These are used by CkAllocateMarshallMsg, below:
        inline int getQueueing(void) const {return queueingtype;}
        inline int getPriorityBits(void) const {return prioBits;}
        inline const prio_t *getPriorityPtr(void) const {return prioPtr;}
+       inline const CkGroupID getGroupDepID() const { return depGroupID; }
 };
 
 #include "CkMarshall.decl.h"
index 84abd118902212ec2bce0450d92326f73fe52a17..c1a1448acb19dbe3310814ce28e28542e11cc8a5 100644 (file)
@@ -186,10 +186,10 @@ typedef struct {
 typedef struct _ckGroupID{
   int idx;             /* pe(processor number) is removed from the structure */
 #ifdef __cplusplus
-  void pup(PUP::er &p) {  p|idx; }
-  int isZero(void) const { return (idx==0); }
-  void setZero(void) { idx=0; }
-  int operator==(const struct _ckGroupID& gid) const {
+  inline void pup(PUP::er &p) {  p|idx; }
+  inline int isZero(void) const { return (idx==0); }
+  inline void setZero(void) { idx=0; }
+  inline int operator==(const struct _ckGroupID& gid) const {
     return (gid.idx==idx);
   }
 #endif
index 3616919e59bbad218103c34b8ac5664ef188aff4..9304fe9c7547bf0538146733d58c9b8ec1de38fe 100644 (file)
@@ -887,11 +887,15 @@ static inline void _processForVidMsg(CkCoreState *ck,envelope *env)
 /************** Receive: Groups ****************/
 
 /**
- This message is sent to this groupID--prepare to
- handle this message by looking up the group,
- and possibly stashing the message.
+ Return a pointer to the local BOC of "groupID".
+ The message "env" passed in has some known dependency on this groupID
+ (either it is to be delivered to this BOC, or it depends on this BOC being there).
+ Therefore, if the return value is NULL, this function buffers the massage so that
+ it will be re-sent (by CkCreateLocalBranch) when this groupID is eventually constructed.
+ The message passed in must have its handlers correctly set so that it can be
+ scheduled again.
 */
-IrrGroup *_lookupGroup(CkCoreState *ck,envelope *env,const CkGroupID &groupID)
+static inline IrrGroup *_lookupGroupAndBufferIfNotThere(CkCoreState *ck,envelope *env,const CkGroupID &groupID)
 {
 
        CmiImmediateLock(CkpvAccess(_groupTableImmLock));
@@ -928,7 +932,7 @@ static inline void _deliverForBocMsg(CkCoreState *ck,int epIdx,envelope *env,Irr
 static inline void _processForBocMsg(CkCoreState *ck,envelope *env)
 {
   register CkGroupID groupID =  env->getGroupNum();
-  register IrrGroup *obj = _lookupGroup(ck,env,env->getGroupNum());
+  register IrrGroup *obj = _lookupGroupAndBufferIfNotThere(ck,env,env->getGroupNum());
   if(obj) {
     _deliverForBocMsg(ck,env->getEpIdx(),env,obj);
   }
@@ -980,6 +984,13 @@ void _processBocInitMsg(CkCoreState *ck,envelope *env)
 {
   register CkGroupID groupID = env->getGroupNum();
   register int epIdx = env->getEpIdx();
+  if (!env->getGroupDep().isZero()) {      // dependence
+    CkGroupID dep = env->getGroupDep();
+    IrrGroup *obj = _lookupGroupAndBufferIfNotThere(ck,env,dep);
+    if (obj == NULL) return;
+  }
+  else
+    ck->process();
   CkCreateLocalGroup(groupID, epIdx, env);
 }
 
@@ -993,14 +1004,14 @@ void _processNodeBocInitMsg(CkCoreState *ck,envelope *env)
 /************** Receive: Arrays *************/
 
 static void _processArrayEltInitMsg(CkCoreState *ck,envelope *env) {
-  CkArray *mgr=(CkArray *)_lookupGroup(ck,env,env->getsetArrayMgr());
+  CkArray *mgr=(CkArray *)_lookupGroupAndBufferIfNotThere(ck,env,env->getsetArrayMgr());
   if (mgr) {
     _SET_USED(env, 0);
     mgr->insertElement((CkMessage *)EnvToUsr(env));
   }
 }
 static void _processArrayEltMsg(CkCoreState *ck,envelope *env) {
-  CkArray *mgr=(CkArray *)_lookupGroup(ck,env,env->getsetArrayMgr());
+  CkArray *mgr=(CkArray *)_lookupGroupAndBufferIfNotThere(ck,env,env->getsetArrayMgr());
   if (mgr) {
     _SET_USED(env, 0);
     mgr->getLocMgr()->deliverInline((CkMessage *)EnvToUsr(env));
@@ -1050,7 +1061,9 @@ void _processHandler(void *converseMsg,CkCoreState *ck)
 // Group support
     case BocInitMsg :
       TELLMSGTYPE(CkPrintf("proc[%d]: _processHandler with msg type: BocInitMsg\n", CkMyPe());)
-      ck->process(); if(env->isPacked()) CkUnpackMessage(&env);
+      // QD processing moved inside _processBocInitMsg because it is conditional
+      //ck->process(); 
+      if(env->isPacked()) CkUnpackMessage(&env);
       _processBocInitMsg(ck,env);
       break;
     case NodeBocInitMsg :
@@ -1438,7 +1451,7 @@ void CkSendMsgInline(int entryIndex, void *msg, const CkChareID *pCid, int opts)
   }
   else {
     //No way to inline a cross-processor message:
-    CkSendMsg(entryIndex,msg,pCid,opts&!CK_MSG_INLINE);
+    CkSendMsg(entryIndex, msg, pCid, opts & (~CK_MSG_INLINE));
   }
 }
 
@@ -1551,7 +1564,7 @@ void CkSendMsgBranchInline(int eIdx, void *msg, int destPE, CkGroupID gID, int o
     }
   }
   //Can't inline-- send the usual way, clear CK_MSG_INLINE
-  CkSendMsgBranch(eIdx,msg,destPE,gID,opts&!CK_MSG_INLINE);
+  CkSendMsgBranch(eIdx, msg, destPE, gID, opts & (~CK_MSG_INLINE));
 }
 
 extern "C"
@@ -1686,7 +1699,7 @@ void CkSendMsgNodeBranchInline(int eIdx, void *msg, int node, CkGroupID gID, int
     }
   }
   //Can't inline-- send the usual way
-  CkSendMsgNodeBranch(eIdx,msg,node,gID,opts&!CK_MSG_INLINE);
+  CkSendMsgNodeBranch(eIdx, msg, node, gID, opts & ~(CK_MSG_INLINE));
 }
 
 extern "C"
index 112535592e732c4a7c724d65cbf1f944fca127a6..fb6455fffddee86de3e18eb78c853fb9db867525 100644 (file)
@@ -419,28 +419,31 @@ CkArrayID CProxy_ArrayBase::ckCreateArray(CkArrayMessage *m,int ctor,
                                          const CkArrayOptions &opts_)
 {
   CkArrayOptions opts(opts_);
-  if (opts.getLocationManager().isZero())
+  CkGroupID locMgr = opts.getLocationManager();
+  if (locMgr.isZero())
   { //Create a new location manager
 #if !CMK_LBDB_ON
     CkGroupID _lbdb;
 #endif
-    opts.setLocationManager(CProxy_CkLocMgr::ckNew(
-      opts.getMap(),_lbdb,opts.getNumInitial()
-      ));
+    locMgr = CProxy_CkLocMgr::ckNew(opts.getMap(),_lbdb,opts.getNumInitial());
+    opts.setLocationManager(locMgr);
   }
   //Create the array manager
   m->array_ep()=ctor;
   CkMarshalledMessage marsh(m);
+  CkEntryOptions  e_opts;
+  e_opts.setGroupDepID(locMgr);       // group creation dependence
 #if !GROUP_LEVEL_REDUCTION
   CProxy_CkArrayReductionMgr nodereductionProxy = CProxy_CkArrayReductionMgr::ckNew();
-  CkGroupID ag=CProxy_CkArray::ckNew(opts,marsh,nodereductionProxy);
+  CkGroupID ag=CProxy_CkArray::ckNew(opts,marsh,nodereductionProxy,&e_opts);
   nodereductionProxy.setAttachedGroup(ag);
 #else
   CkNodeGroupID dummyid;
-  CkGroupID ag=CProxy_CkArray::ckNew(opts,marsh,dummyid);
+  CkGroupID ag=CProxy_CkArray::ckNew(opts,marsh,dummyid,&e_opts);
 #endif
   return (CkArrayID)ag;
 }
+
 CkArrayID CProxy_ArrayBase::ckCreateEmptyArray(void)
 {
   return ckCreateArray((CkArrayMessage *)CkAllocSysMsg(),0,CkArrayOptions());
@@ -498,8 +501,6 @@ void CProxySection_ArrayBase::pup(PUP::er &p)
 }
 
 /*********************** CkArray Creation *************************/
-CkpvDeclare(CkVec<CkArrayMgrWaiting>, waitingArrayMgrs);
-
 void _ckArrayInit(void)
 {
   CkpvInitialize(ArrayElement_initInfo,initInfo);
@@ -508,7 +509,6 @@ void _ckArrayInit(void)
     // disable because broadcast listener may deliver broadcast message
   CkDisableTracing(CkIndex_CkLocMgr::immigrate(0));
   // by default anytime migration is allowed
-  CkpvInitialize(CkVec<CkArrayMgrWaiting>, waitingArrayMgrs);
 }
 
 CkArray::CkArray(CkArrayOptions &c,CkMarshalledMessage &initMsg,CkNodeGroupID nodereductionID)
@@ -517,12 +517,7 @@ CkArray::CkArray(CkArrayOptions &c,CkMarshalledMessage &initMsg,CkNodeGroupID no
   thisProxy(thisgroup)
 {
   //Registration
-  if (locMgr != 0) {
-    elements=(ArrayElementList *)locMgr->addManager(thisgroup,this);
-  } else {
-    elements=NULL;
-    CkpvAccess(waitingArrayMgrs).insertAtEnd(CkArrayMgrWaiting(locMgrID, this));
-  }
+  elements=(ArrayElementList *)locMgr->addManager(thisgroup,this);
 //  moved to _ckArrayInit()
 //  CkpvInitialize(ArrayElement_initInfo,initInfo);
   CcdCallOnConditionKeep(CcdPERIODIC_1minute,staticSpringCleaning,(void *)this);
@@ -548,11 +543,7 @@ CkArray::CkArray(CkArrayOptions &c,CkMarshalledMessage &initMsg,CkNodeGroupID no
   for (int l=0;l<listeners.size();l++) listeners[l]->ckBeginInserting();
 
   ///Set up initial elements (if any)
-  if (locMgr != 0) {
-    locMgr->populateInitial(numInitial,initMsg.getMessage(),this);
-  } else {
-    msgsWaitingForLocMgr.insertAtEnd(initMsg.getMessage());
-  }
+  locMgr->populateInitial(numInitial,initMsg.getMessage(),this);
 
   ///adding code for Reduction using nodegroups
 
@@ -598,22 +589,6 @@ void CkArray::pup(PUP::er &p){
        }
 }
 
-/**
- * In case there was a race condidion and the ArrayMgr was created before the LocMgr,
- * the initial creation message and the broadcasts are temporarily buffered.
- * All the messages are stored in "msgWaitingForLocMgr", the initial creation message
- * in position zero (avoiding an extra field in CkArray).
- */
-void CkArray::notifyLocMgrCreated(CkLocMgr *mgr) {
-  locMgr = mgr;
-  elements=(ArrayElementList *)locMgr->addManager(thisgroup,this);
-  locMgr->populateInitial(numInitial,msgsWaitingForLocMgr[0],this);
-  for (int i=1; i<msgsWaitingForLocMgr.size(); ++i) {
-    recvBroadcast(msgsWaitingForLocMgr[i]);
-  }
-  msgsWaitingForLocMgr.free();
-}
-
 #define CK_ARRAYLISTENER_STAMP_LOOP(listenerData) do {\
   int dataOffset=0; \
   for (int lNo=0;lNo<listeners.size();lNo++) { \
@@ -796,10 +771,16 @@ void CProxyElement_ArrayBase::ckSend(CkArrayMessage *msg, int ep, int opts) cons
          ckDelegatedTo()->ArraySend(ckDelegatedPtr(),ep,msg,_idx,ckGetArrayID());
        else 
        { //Usual case: a direct send
-         if (opts & CK_MSG_INLINE)
-           ckLocalBranch()->deliver(msg, CkDeliver_inline, opts&!CK_MSG_INLINE);
-         else
-           ckLocalBranch()->deliver(msg, CkDeliver_queue, opts);
+         CkArray *localbranch = ckLocalBranch();
+         if (localbranch == NULL) {             // array not created yet
+           CkArrayManagerDeliver(CkMyPe(), msg, 0);
+          }
+         else {
+           if (opts & CK_MSG_INLINE)
+             localbranch->deliver(msg, CkDeliver_inline, opts & (~CK_MSG_INLINE));
+           else
+             localbranch->deliver(msg, CkDeliver_queue, opts);
+         }
        }
 }
 
@@ -837,7 +818,10 @@ void CkSendMsgArray(int entryIndex, void *msg, CkArrayID aID, const CkArrayIndex
   m->array_index()=idx;
   msg_prepareSend(m,entryIndex,aID);
   CkArray *a=(CkArray *)_localBranch(aID);
-  a->deliver(m,CkDeliver_queue,opts);
+  if (a == NULL)
+    CkArrayManagerDeliver(CkMyPe(), msg, 0);
+  else
+    a->deliver(m,CkDeliver_queue,opts);
 }
 
 void CkSendMsgArrayInline(int entryIndex, void *msg, CkArrayID aID, const CkArrayIndex &idx, int opts)
@@ -1066,15 +1050,11 @@ void CkArray::staticBroadcastHomeElements(CkArray *arr,void *data,CkLocRec *rec,
 }
 #endif
 
+
 /// Increment broadcast count; deliver to all local elements
 void CkArray::recvBroadcast(CkMessage *m)
 {
        CK_MAGICNUMBER_CHECK
-    if (elements == NULL) {
-      // The location manager has been created yet. Delay the delivery...
-      msgsWaitingForLocMgr.insertAtEnd(m);
-      return;
-    }
        CkArrayMessage *msg=(CkArrayMessage *)m;
        broadcaster->incoming(msg);
 #ifdef _FAULT_MLOG_
index d1ff3e975a514df3b08ca3e1c46cee39ea6c118d..ea4e8eb08f2f129672d8a24e9ef837d7cfd6e4da 100644 (file)
@@ -742,14 +742,12 @@ class CkArray : public CkReductionMgr, public CkArrMgr {
   CProxy_CkArray thisProxy;
   typedef CkMigratableListT<ArrayElement> ArrayElementList;
   ArrayElementList *elements;
-  CkVec<CkMessage*> msgsWaitingForLocMgr;
 
 public:
 //Array Creation:
   CkArray(CkArrayOptions &c,CkMarshalledMessage &initMsg,CkNodeGroupID nodereductionProxy);
   CkArray(CkMigrateMessage *m);
   CkGroupID &getGroupID(void) {return thisgroup;}
-  void notifyLocMgrCreated(CkLocMgr *mgr);
 
 //Access & information routines
   inline CkLocMgr *getLocMgr(void) {return locMgr;}
index b7cb70480c60ceeba94a69923ba7ff96b2f4839f..46ee18ab45129379050835c540a1c2e883a9c0ee 100644 (file)
@@ -1684,8 +1684,6 @@ void CkLocMgr::callForAllRecords(CkLocFn fnPointer,CkArray *arr,void *data){
 }
 #endif
 
-#include "ckarray.h"
-
 /*************************** LocMgr: CREATION *****************************/
 CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkArrayIndexMax& numInitial)
        :thisProxy(thisgroup),thislocalproxy(thisgroup,CkMyPe()),
@@ -1713,16 +1711,6 @@ CkLocMgr::CkLocMgr(CkGroupID mapID_,CkGroupID lbdbID_,CkArrayIndexMax& numInitia
        lbdbID = lbdbID_;
        initLB(lbdbID_);
        hashImmLock = CmiCreateImmediateLock();
-       
-       //Add the array managers that happen to have been created before this
-       for (int i=0; i<CkpvAccess(waitingArrayMgrs).size(); ++i) {
-         CkArrayMgrWaiting &mgr = CkpvAccess(waitingArrayMgrs)[i];
-         if (mgr.id==thisgroup) {
-           mgr.array->notifyLocMgrCreated(this);
-           CkpvAccess(waitingArrayMgrs).remove(i);
-           --i;
-         }
-       }
 }
 
 CkLocMgr::CkLocMgr(CkMigrateMessage* m)
index 3c3356ed8e8e6575d395347358c731efbd5286a2..936c46535f47278d00f9aca1cbc24d4f71954286 100644 (file)
@@ -752,20 +752,7 @@ public:
 };
 
 
-class CkArrayMgrWaiting {
-public:
-  CkGroupID id;
-  CkArray *array;
-  CkArrayMgrWaiting(): array(NULL) { id.setZero(); }
-  CkArrayMgrWaiting(CkGroupID _id, CkArray *_array): id(_id), array(_array) { }
-};
-/**
- * A table to contain a list of array managers waiting on specific location
- * managers to be created (due to message races).
- * Efficiency should not be a problem, since this is a quite rare condition,
- * and there are not many array managers anyway in a program.
- */
-CkpvExtern(CkVec<CkArrayMgrWaiting>, waitingArrayMgrs);
+
 
 
 /// check the command line arguments to determine if we can use ConfigurableRRMap
index d2251077cd18a0207677bfc2ada5a06ed58749b8..5e0026f7bbdda856c705346160c8cad8137ae1dc 100644 (file)
@@ -155,6 +155,7 @@ public:
       struct s_group {         // NodeBocInitMsg, BocInitMsg, ForNodeBocMsg, ForBocMsg
         CkGroupID g;           ///< GroupID
         CkNodeGroupID rednMgr; ///< Reduction manager for this group (constructor only!)
+        CkGroupID dep;         ///< create after dep is created (constructor only!)
         int epoch;             ///< "epoch" this group was created during (0--mainchare, 1--later)
         UShort arrayEp;        ///< Used only for array broadcasts
       } group;
@@ -247,6 +248,7 @@ private:
       env->totalsize = tsize;
       env->priobits = prio;
       env->setPacked(0);
+      env->type.group.dep.setZero();
       _SET_USED(env, 0);
       //for record-replay
       env->setEvent(++CkpvAccess(envelopeEventID));
@@ -330,6 +332,8 @@ private:
     int getGroupEpoch(void) { return type.group.epoch; }
     void setRednMgr(CkNodeGroupID r){ type.group.rednMgr = r; }
     CkNodeGroupID getRednMgr(){ return type.group.rednMgr; }
+    CkGroupID getGroupDep(){ return type.group.dep; }
+    void setGroupDep(const CkGroupID &r){ type.group.dep = r; }
 
 // Array-specific fields
     CkGroupID &getsetArrayMgr(void) {return type.array.arr;}
index c44a5dbe9ea172a72c657004ea25c86e213ea44a..e587c1d2400e0c3b35e2cd6ee7b2e65cbe7a5e3f 100644 (file)
@@ -527,9 +527,9 @@ static inline void _processBufferedMsgs(void)
       if(env->isForAnyPE())
         CldEnqueue(CLD_ANYWHERE, env, _infoIdx);
       else
-        CmiSyncSendAndFree(CkMyPe(), env->getTotalsize(), (char *)env);
+        _processHandler((void *)env, CkpvAccess(_coreState));
     } else {
-      CmiSyncSendAndFree(CkMyPe(), env->getTotalsize(), (char *)env);
+      _processHandler((void *)env, CkpvAccess(_coreState));
     }
   }
 }
@@ -663,7 +663,8 @@ static void _initHandler(void *msg, CkCoreState *ck)
     case BocInitMsg:
       if (env->getGroupEpoch()==0) {
         CkpvAccess(_numInitsRecd)++;
-        CpvAccess(_qd)->process();
+       // _processBocInitMsg already handles QD
+        //CpvAccess(_qd)->process();
         CkpvAccess(_bocInitVec)->insert(env->getGroupNum().idx, env);
       } else _bufferHandler(msg);
       break;
index 4f1374e4b38aafab42b4368908e170c1f66e7342..a4e8fd05105699898a2d62451458fc7344cc2d1f 100644 (file)
@@ -107,9 +107,11 @@ CkMarshallMsg *CkAllocateMarshallMsgNoninline(int size,const CkEntryOptions *opt
        //Copy the user's priority data into the message
        envelope *env=UsrToEnv(m);
        setMemoryTypeMessage(env);
+       if (opts->getPriorityPtr() != NULL)
        CmiMemcpy(env->getPrioPtr(),opts->getPriorityPtr(),env->getPrioBytes());
        //Set the message's queueing type
        env->setQueueing((unsigned char)opts->getQueueing());
+       env->setGroupDep(opts->getGroupDepID());
        return m;
 }
 
index 6b293ae4e45d0564ee6d4dfc608580595a6110c2..cf4a1f8f5177607e2e12165de793d6b17578486e 100644 (file)
@@ -283,6 +283,11 @@ controlPointManager::controlPointManager(){
       iss >> ips->idleTime.avg;
       iss >> ips->idleTime.max;
 
+      // Read overhead time
+      iss >> ips->overheadTime.min;
+      iss >> ips->overheadTime.avg;
+      iss >> ips->overheadTime.max;
+
       // read bytePerInvoke
       iss >> ips->bytesPerInvoke;
 
@@ -785,6 +790,10 @@ controlPointManager::controlPointManager(){
       prevPhase->idleTime.avg = idle[1]/CkNumPes();
       prevPhase->idleTime.max = idle[2];
       
+      prevPhase->overheadTime.min = over[0];
+      prevPhase->overheadTime.avg = over[1]/CkNumPes();
+      prevPhase->overheadTime.max = over[2];
+      
       prevPhase->memoryUsageMB = mem[0];
       
       CkPrintf("Stored idle time min=%lf, mem=%lf in prevPhase=%p\n", (double)prevPhase->idleTime.min, (double)prevPhase->memoryUsageMB, prevPhase);
@@ -1258,6 +1267,8 @@ void controlPointManager::generatePlan() {
       
       std::vector<std::map<std::string,int> > possibleNextStepPlans;
 
+
+      // ========================================= Concurrency =============================================
       // See if idle time is high:
       double idleTime = twoAgoPhase->idleTime.avg;
       CkPrintf("Steering encountered idle time (%f)\n", idleTime);
@@ -1265,20 +1276,66 @@ void controlPointManager::generatePlan() {
       if(idleTime > 0.10){
        CkPrintf("Steering encountered high idle time(%f) > 10%%\n", idleTime);
        CkPrintf("Steering controlPointSpace.size()=\n", controlPointSpace.size());
+       
+       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > > &possibleCPsToTune = CkpvAccess(cp_effects)["Concurrency"];
+       
+       bool found = false;
+       std::string cpName;
+       std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > *info;
+       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > >::iterator iter;
+       for(iter = possibleCPsToTune.begin(); iter != possibleCPsToTune.end(); iter++){
+         cpName = iter->first;
+         info = &iter->second;
+         
+         // Initialize a new plan based on two phases ago
+         std::map<std::string,int> aNewPlan;
+         
+         std::map<std::string, std::pair<int,int> >::const_iterator cpsIter;
+         for(cpsIter=controlPointSpace.begin(); cpsIter != controlPointSpace.end(); ++cpsIter){
+           const std::string &name = cpsIter->first;
+           const int& twoAgoValue =  twoAgoPhase->controlPoints[name];
+           aNewPlan[name] = twoAgoValue;
+         }
+         
+         CkPrintf("Steering found knob to turn\n");
+         fflush(stdout);
+
+         if(info->first == ControlPoint::EFF_INC){
+           const int maxValue = controlPointSpace[cpName].second;
+           const int twoAgoValue =  twoAgoPhase->controlPoints[cpName];
+           if(twoAgoValue+1 <= maxValue){
+             aNewPlan[cpName] = twoAgoValue+1; // increase from two phases back
+           }
+         } else {
+           const int minValue = controlPointSpace[cpName].second;
+           const int twoAgoValue =  twoAgoPhase->controlPoints[cpName];
+           if(twoAgoValue-1 >= minValue){
+             aNewPlan[cpName] = twoAgoValue-1; // decrease from two phases back
+           }
+         }
 
+         possibleNextStepPlans.push_back(aNewPlan);
+         
+       }
+      }
 
-       // Initialize the future plan to be the values from two phases ago (later we might adjust this)
 
-       CkPrintf("Steering initialized plan\n");
-       fflush(stdout);
+      // ========================================= Grain Size =============================================
+      // If the grain size is too small, there may be tons of messages and overhead time associated with scheduling
+      
+      double overheadTime = twoAgoPhase->overheadTime.avg;
+      CkPrintf("Steering encountered overhead time (%f)\n", overheadTime);
+      fflush(stdout);
+      if(overheadTime > 0.10){
+       CkPrintf("Steering encountered high overhead time(%f) > 10%%\n", overheadTime);
+       CkPrintf("Steering controlPointSpace.size()=\n", controlPointSpace.size());
 
-       // look for a possible control point knob to turn
-       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > > &possibleCPsToTune = CkpvAccess(cp_effects)["Concurrency"];
+       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > > &possibleCPsToTune = CkpvAccess(cp_effects)["GrainSize"];   
        
        bool found = false;
        std::string cpName;
        std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > *info;
-       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > >::iterator iter;
+       std::map<std::string, std::pair<int, std::vector<ControlPoint::ControlPointAssociation> > >::iterator iter;     
        for(iter = possibleCPsToTune.begin(); iter != possibleCPsToTune.end(); iter++){
          cpName = iter->first;
          info = &iter->second;
@@ -1314,7 +1371,11 @@ void controlPointManager::generatePlan() {
          
        }
 
-      }
+    }
+
+
+      // ========================================= Done =============================================
+
 
       if(possibleNextStepPlans.size() > 0){
        newControlPoints = possibleNextStepPlans[0];
index b4c025c0bb3149b80b1962a2a2f058cf284283b3..d11f8c860c4ddce420d8976c13c00f066e9db553 100644 (file)
@@ -133,6 +133,32 @@ public:
 }; 
 
 
+/// A container that stores overhead statistics (min/max/avg etc.)
+class overheadContainer {
+public:
+  double min;
+  double avg;
+  double max;
+  
+  overheadContainer(){
+    min = -1.0;
+    max = -1.0;
+    avg = -1.0;
+  }
+  
+  bool isValid() const{
+    return (min >= 0.0 && avg >= min && max >= avg && max <= 1.0);
+  }
+  
+  void print() const{
+    if(isValid())
+      CkPrintf("[%d] Overhead Time is Min=%.2lf%% Avg=%.2lf%% Max=%.2lf%%\n", CkMyPe(), min*100.0, avg*100.0, max*100.0);    
+    else
+      CkPrintf("[%d] Overhead Time is invalid\n", CkMyPe(), min*100.0, avg*100.0, max*100.0);
+  }
+  
+}; 
+
 
 
 /// Stores data for a phase (a time range in which a single set of control point values is used).
@@ -150,6 +176,8 @@ public:
   double memoryUsageMB;
 
   idleTimeContainer idleTime;
+  overheadContainer overheadTime;
+
 
   /** Approximately records the average message size for an entry method. */
   double bytesPerInvoke;
@@ -409,7 +437,7 @@ public:
       s << "# There are " << ps.size()  << " control points\n";
       s << "# number of recorded phases: " << phases.size() << "\n";
       
-      s << "# Memory (MB)\tIdle Min\tIdle Avg\tIdle Max\tByte Per Invoke\tGrain Size\t";
+      s << "# Memory (MB)\tIdle Min\tIdle Avg\tIdle Max\tOverhead Min\tOverhead Avg\tOverhead Max\tByte Per Invoke\tGrain Size\t";
       for(cpiter = ps.begin(); cpiter != ps.end(); cpiter++){
        s << cpiter->first << "\t";
       }
@@ -423,6 +451,8 @@ public:
        s << (*runiter)->memoryUsageMB << "\t"; 
 
        s << (*runiter)->idleTime.min << "\t" << (*runiter)->idleTime.avg << "\t" << (*runiter)->idleTime.max << "\t";
+       s << (*runiter)->overheadTime.min << "\t" << (*runiter)->overheadTime.avg << "\t" << (*runiter)->overheadTime.max << "\t";
+
 
        s << (*runiter)->bytesPerInvoke << "\t";
 
index ea317b772869eb40d4d9c194bd45356dc292c559..2591f2ace76f6faec27c7db05421660c3e5e8be8 100644 (file)
@@ -32,6 +32,8 @@ TraceControlPoints::TraceControlPoints(char **argv)
 {
   resetTimings();
 
+  nesting_level = 0;
+
   b1=0;
   b2=0;
   b3=0;
@@ -70,58 +72,56 @@ void TraceControlPoints::messageRecv(char *env, int pe) {
   
 void TraceControlPoints::beginExecute(CmiObjId *tid)
 {
-  // CmiObjId is a 4-integer tuple uniquely identifying a migratable
-  //   Charm++ object. Note that there are other non-migratable Charm++
-  //   objects that CmiObjId will not identify.
-  b1++;
-  lastBeginExecuteTime = CmiWallTimer();
-  lastbeginMessageSize = -1;
-
-  //  CkPrintf("[%d] TraceControlPoints::beginExecute(CmiObjId *tid)\n", CkMyPe());
+  nesting_level++;
+  if(nesting_level == 1){
+    // CmiObjId is a 4-integer tuple uniquely identifying a migratable
+    //   Charm++ object. Note that there are other non-migratable Charm++
+    //   objects that CmiObjId will not identify.
+    b1++;
+    lastBeginExecuteTime = CmiWallTimer();
+    lastbeginMessageSize = -1;
+  }
 }
 
-void TraceControlPoints::beginExecute(envelope *e)
-{
-  lastBeginExecuteTime = CmiWallTimer();
-  lastbeginMessageSize = e->getTotalsize();
-  b2++;
-  b2mlen += lastbeginMessageSize;
-  //  CkPrintf("[%d] WARNING ignoring TraceControlPoints::beginExecute(envelope *e)\n", CkMyPe());
 
-  // no message means thread execution
-  //  if (e != NULL) {
-  //  CkPrintf("[%d] TraceControlPoints::beginExecute  Method=%d, type=%d, source pe=%d, size=%d\n", 
-  //        CkMyPe(), e->getEpIdx(), e->getMsgtype(), e->getSrcPe(), e->getTotalsize() );
-  //}  
-
-  //  CkPrintf("[%d] TraceControlPoints::beginExecute(envelope *e=%p)\n", CkMyPe(), e);
 
+void TraceControlPoints::beginExecute(envelope *e)
+{
+  nesting_level++;
+  if(nesting_level == 1){
+    lastBeginExecuteTime = CmiWallTimer();
+    lastbeginMessageSize = e->getTotalsize();
+    b2++;
+    b2mlen += lastbeginMessageSize;
+  }
 }
  
 void TraceControlPoints::beginExecute(int event,int msgType,int ep,int srcPe, 
                               int mlen, CmiObjId *idx)
 {
-  b3++;
-  b3mlen += mlen;
-  lastBeginExecuteTime = CmiWallTimer();
-  lastbeginMessageSize = mlen;
-  //  CkPrintf("[%d] TraceControlPoints::beginExecute event=%d, msgType=%d, ep=%d, srcPe=%d, mlen=%d CmiObjId is also avaliable\n", CkMyPe(), event, msgType, ep, srcPe, mlen);
-  //  CkPrintf("[%d] TraceControlPoints::beginExecute(int event,int msgType,int ep,int srcPe, int mlen, CmiObjId *idx)\n", CkMyPe());
-
+  nesting_level++;
+  if(nesting_level == 1){
+    b3++;
+    b3mlen += mlen;
+    lastBeginExecuteTime = CmiWallTimer();
+    lastbeginMessageSize = mlen;
+  }
 }
 
 void TraceControlPoints::endExecute(void)
 {
-  double executionTime = CmiWallTimer() - lastBeginExecuteTime;
-  totalEntryMethodTime += executionTime;
-  totalEntryMethodInvocations ++;
-
-  double m = (double)CmiMemoryUsage();
-  if(memUsage < m){
-    memUsage = m;
+  nesting_level--;
+  if(nesting_level == 0){
+    
+    double executionTime = CmiWallTimer() - lastBeginExecuteTime;
+    totalEntryMethodTime += executionTime;
+    totalEntryMethodInvocations ++;
+    
+    double m = (double)CmiMemoryUsage();
+    if(memUsage < m){
+      memUsage = m;
+    }    
   }
-
-  //  CkPrintf("[%d] Previously executing Entry Method completes. lastbeginMessageSize=%d executionTime=%lf\n", CkMyPe(), lastbeginMessageSize, executionTime);
 }
 
 void TraceControlPoints::beginIdle(double curWallTime) {
index 4e0b654de376e25f486ba26d2de1502555d065d9..9b2829437902af29ac00cee9dbca92426cef35d3 100644 (file)
@@ -52,6 +52,10 @@ class TraceControlPoints : public Trace {
   long b2mlen;
   long b3mlen;
 
+  // In some programs like Changa, entry methods may be nested, and hence we only want to consider the outermost one
+  int nesting_level;
+
+
  public:
   TraceControlPoints(char **argv);
   
index 8e92cfd325d2deb929dd8704faf3fe95ba320be4..9f356819a4eb2b9beef9278774057e6524e5af91 100644 (file)
@@ -198,6 +198,7 @@ int CtgGlobalList::isUserSymbol(const char *name) {
        || (strncmp("Csv_", name, 4) == 0) || (strncmp("Ctv_", name, 4) == 0)
        || (strncmp("Bnv_", name, 4) == 0) || (strncmp("Bpv_", name, 4) == 0)
        || (strncmp("ckout", name, 5) == 0) || (strncmp("stdout", name, 6) == 0)
+       || (strncmp("ckerr", name, 5) == 0)
        || (strncmp("environ", name, 7) == 0)
        || (strncmp("stderr", name, 6) == 0) || (strncmp("stdin", name, 5) == 0)) {
 #ifdef CMK_GFORTRAN
index 47768564d314029f24e25460d725f02ff0ead9cb..997518c7ec1a7d10b7eac636a460454a7997d84d 100644 (file)
@@ -6,7 +6,7 @@ CUDAC = nvcc
 CUDAINC = -I$(CUDASDK)/common/inc -I$(CUDADIR)/include
 
 CHARMC=$(CDIR)/bin/charmc -cc $(CUDAC) -c++ $(CUDAC) $(OPTS) -nobs
-CCFLAGS = -DCUDA -DFP_TYPE_FLOAT  -O2 -DSHARED_NODES_ONLY_NEIGHBOR
+CCFLAGS = -DCUDA -DFP_TYPE_FLOAT  -g -DSHARED_NODES_ONLY_NEIGHBOR
 
 
 #Headers to be copied to include directory so application users can see them
index 3bfd4048950fd4ee136e0011dc8fba00cd84fe9e..d8adf58d367893f7a962bdf2a1cb1202cbf7a02c 100644 (file)
@@ -79,7 +79,7 @@ void fillIDHash(MeshModel* model)
 // If the number of nodes or elements increases, then this function should be called
 // because the attribute arrays may have been resized, after which the old pointers
 // would be invalid.
-void setTableReferences(MeshModel* model, bool recomputeHash=false)
+void setTableReferences(MeshModel* model, bool recomputeHash)
 {
     model->ElemConn_T = &((FEM_IndexAttribute*)model->mesh->elem[MESH_ELEMENT_TET4].lookup(FEM_CONN,""))->get();
     model->elem_id_T = &((FEM_DataAttribute*)model->mesh->elem[MESH_ELEMENT_TET4].lookup(ATT_ELEM_ID,""))->getInt();
@@ -185,8 +185,8 @@ MeshModel* meshModel_Create_Init(){
   data values which were not done in init.
 
 */
-MeshModel* meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
-        int node_attr_sz, int model_attr_sz, void *mAtt) {
+void meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
+        int node_attr_sz, int model_attr_sz, void *mAtt, MeshModel &model) {
 
     CkAssert(ATT_NODE_ID != FEM_COORD);
     CkAssert(ATT_NODE_DATA != FEM_COORD);
@@ -204,37 +204,37 @@ MeshModel* meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
     CkAssert(elem_attr_sz > 0);
     CkAssert(node_attr_sz > 0);
     int which_mesh=FEM_Mesh_default_read();
-    MeshModel *model = new MeshModel;
-    memset(model, 0, sizeof(MeshModel));
+
+    memset(&model, 0, sizeof(MeshModel));
     
-    model->target_device = target_device;
-    model->elem_attr_size = elem_attr_sz;
-    model->node_attr_size = node_attr_sz;
-    model->model_attr_size = model_attr_sz;
+    model.target_device = target_device;
+    model.elem_attr_size = elem_attr_sz;
+    model.node_attr_size = node_attr_sz;
+    model.model_attr_size = model_attr_sz;
     
-    model->mesh = FEM_Mesh_lookup(which_mesh,"meshModel_Create_Driver");
-    model->mAtt = mAtt;
+    model.mesh = FEM_Mesh_lookup(which_mesh,"meshModel_Create_Driver");
+    model.mAtt = mAtt;
     
-    model->num_local_elem = model->mesh->elem[MESH_ELEMENT_TET4].size();
-    model->num_local_node = model->mesh->node.size();
+    model.num_local_elem = model.mesh->elem[MESH_ELEMENT_TET4].size();
+    model.num_local_node = model.mesh->node.size();
 
     // Allocate user model attributes
     FEM_Mesh_become_set(which_mesh);
-    char* temp_array = (char*) malloc(model->num_local_elem * model->elem_attr_size);
-    FEM_Mesh_data(which_mesh,FEM_ELEM+MESH_ELEMENT_TET4,ATT_ELEM_DATA,temp_array,0,model->num_local_elem,FEM_BYTE,model->elem_attr_size);
+    char* temp_array = (char*) malloc(model.num_local_elem * model.elem_attr_size);
+    FEM_Mesh_data(which_mesh,FEM_ELEM+MESH_ELEMENT_TET4,ATT_ELEM_DATA,temp_array,0,model.num_local_elem,FEM_BYTE,model.elem_attr_size);
     free(temp_array);
 
-    temp_array = (char*) malloc(model->num_local_node * model->node_attr_size);
-    FEM_Mesh_data(which_mesh,FEM_NODE,ATT_NODE_DATA,temp_array,0,model->num_local_node,FEM_BYTE,model->node_attr_size);
+    temp_array = (char*) malloc(model.num_local_node * model.node_attr_size);
+    FEM_Mesh_data(which_mesh,FEM_NODE,ATT_NODE_DATA,temp_array,0,model.num_local_node,FEM_BYTE,model.node_attr_size);
     free(temp_array);
 
 
-    const int connSize = model->mesh->elem[MESH_ELEMENT_TET4].getConn().width();
-    temp_array = (char*) malloc(model->num_local_node * connSize);
+    const int connSize = model.mesh->elem[MESH_ELEMENT_TET4].getConn().width();
+    temp_array = (char*) malloc(model.num_local_node * connSize);
     FEM_Mesh_data(which_mesh,FEM_ELEM+MESH_ELEMENT_TET4,ATT_ELEM_N2E_CONN,temp_array, 0, 1, FEM_INT, connSize);
     free(temp_array);
 
-    setTableReferences(model, true);
+    setTableReferences(&model, true);
 
     // Setup the adjacencies
     int nodesPerTuple = 3;
@@ -244,9 +244,9 @@ MeshModel* meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
     FEM_Add_elem2face_tuples(which_mesh, MESH_ELEMENT_TET4,  nodesPerTuple, tuplesPerTet, tetFaces);
     FEM_Add_elem2face_tuples(which_mesh, MESH_ELEMENT_COH3T3,  nodesPerTuple, tuplesPerCoh, cohFaces);
 
-    model->mesh->createNodeElemAdj();
-    model->mesh->createNodeNodeAdj();
-    model->mesh->createElemElemAdj();
+    model.mesh->createNodeElemAdj();
+    model.mesh->createNodeNodeAdj();
+    model.mesh->createElemElemAdj();
 
 #if CUDA
     int* n2eTable;
@@ -254,16 +254,16 @@ MeshModel* meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
     FEM_Mesh_create_node_elem_adjacency(which_mesh);
     FEM_Mesh* mesh = FEM_Mesh_lookup(which_mesh, "meshModel_Create_Driver");
     FEM_DataAttribute * at = (FEM_DataAttribute*) 
-        model->mesh->elem[MESH_ELEMENT_TET4].lookup(ATT_ELEM_N2E_CONN,"meshModel_Create_Driver");
+        model.mesh->elem[MESH_ELEMENT_TET4].lookup(ATT_ELEM_N2E_CONN,"meshModel_Create_Driver");
     n2eTable = at->getInt().getData();
 
     FEM_IndexAttribute * iat = (FEM_IndexAttribute*) 
-        model->mesh->elem[MESH_ELEMENT_TET4].lookup(FEM_CONN,"meshModel_Create_Driver");
+        model.mesh->elem[MESH_ELEMENT_TET4].lookup(FEM_CONN,"meshModel_Create_Driver");
     int* connTable  = iat->get().getData();
 
     int* adjElements;
     int size;
-    for (int i=0; i<model->num_local_node; ++i) {
+    for (int i=0; i<model.num_local_node; ++i) {
         mesh->n2e_getAll(i, adjElements, size);
         for (int j=0; j<size; ++j) {
             for (int k=0; k<connSize+1; ++k) {
@@ -297,12 +297,11 @@ MeshModel* meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
     FEM_Mesh_become_get(which_mesh);
 
 #if CUDA
-    if (model->target_device == DeviceGPU) {
-      allocateModelForCUDADevice(model);
+    if (model.target_device == DeviceGPU) {
+      allocateModelForCUDADevice(&model);
     }
 #endif
 
-    return model;
 }
 
 
index a87973f1c47bc26764312c8f5284cf212d572771..5bfddd5fd943dd4527fca9e739a859daa011351b 100644 (file)
@@ -70,6 +70,34 @@ class MeshModel{
             elemIDHash = NULL;
            allocatedForCUDADevice = false;
         }
+
+
+       void print(){
+         CkPrintf("MeshModel::print() on pe %d\n", CkMyPe());
+         CkPrintf("mesh=%p\n", mesh);
+         CkPrintf("mAtt=%p\n", mAtt);
+         CkPrintf("ElemData_T = %p\n", ElemData_T );
+         CkPrintf("GhostElemData_T = %p\n", GhostElemData_T);
+         CkPrintf("NodeData_T = %p\n", NodeData_T);
+          CkPrintf("GhostNodeData_T = %p\n", GhostNodeData_T);
+          CkPrintf("ElemConn_T = %p\n", ElemConn_T);
+          CkPrintf("coord_T = %p\n", coord_T);
+          CkPrintf("node_id_T = %p\n", node_id_T);
+          CkPrintf("elem_id_T = %p\n", elem_id_T);
+          CkPrintf("n2eConn_T = %p\n", n2eConn_T);
+
+          CkPrintf("nodeIDHash = %p\n", nodeIDHash);
+         CkPrintf("elemIDHash = %p\n", elemIDHash);
+
+         CkPrintf("node_attr_size = %d\n", node_attr_size);
+         CkPrintf("elem_attr_size = %d\n", elem_attr_size);
+          CkPrintf("model_attr_size = %d\n", model_attr_size);    
+          CkPrintf("num_local_elem = %d\n", num_local_elem);
+          CkPrintf("num_local_node = %d\n", num_local_node);
+          CkPrintf("target_device = %d\n", target_device);
+
+       }
+
 };
 
 
@@ -155,8 +183,8 @@ MeshModel* meshModel_Create_Init();
 
 
 /** Create and access a mesh model. Only call from Driver */
-MeshModel* meshModel_Create_Driver(MeshDevice target_device,
-        int elem_attr_sz, int node_attr_sz, int model_attr_sz, void* mAtt);
+void meshModel_Create_Driver(MeshDevice target_device,
+        int elem_attr_sz, int node_attr_sz, int model_attr_sz, void* mAtt, MeshModel &model);
 
 /** Cleanup a model. Currently does nothing */
 void meshModel_Destroy(MeshModel* m);
@@ -659,4 +687,9 @@ inline void meshFacetItr_Destroy (MeshFacetItr* itr){
 #endif
 
 
+
+
+void setTableReferences(MeshModel* model, bool recomputeHash=false);
+
+
 #endif
index fa3c7b64188fd6a99eb1465f6304ddabc7f9a97b..279dfa1c88e9ddde6546dee361ac8a8c1af861be 100644 (file)
@@ -28,7 +28,7 @@ static CkDDT *getDDT(void) {
 //------------- startup -------------
 static mpi_comm_worlds mpi_worlds;
 
-int mpi_nworlds; /*Accessed by ampif*/
+int _mpi_nworlds; /*Accessed by ampif*/
 int MPI_COMM_UNIVERSE[MPI_MAX_COMM_WORLDS]; /*Accessed by user code*/
 
 /* ampiReducer: AMPI's generic reducer type 
@@ -451,7 +451,7 @@ static int AMPI_threadstart_idx = -1;
 
 static void ampiNodeInit(void)
 {
-  mpi_nworlds=0;
+  _mpi_nworlds=0;
   for(int i=0;i<MPI_MAX_COMM_WORLDS; i++)
   {
     MPI_COMM_UNIVERSE[i] = MPI_COMM_WORLD+1+i;
@@ -629,11 +629,11 @@ static ampi *ampiInit(char **argv)
 
 // FIXME: Need to serialize global communicator allocation in one place.
        //Allocate the next communicator
-       if(mpi_nworlds == MPI_MAX_COMM_WORLDS)
+       if(_mpi_nworlds == MPI_MAX_COMM_WORLDS)
        {
                CkAbort("AMPI> Number of registered comm_worlds exceeded limit.\n");
        }
-       int new_idx=mpi_nworlds;
+       int new_idx=_mpi_nworlds;
        new_world=MPI_COMM_WORLD+new_idx; // Isaac guessed there shouldn't be a +1 here
 
         //Create and attach the ampiParent array
@@ -749,7 +749,7 @@ public:
     void add(const ampiCommStruct &nextWorld) {
       int new_idx=nextWorld.getComm()-(MPI_COMM_WORLD); // Isaac guessed there shouldn't be a +1 after the MPI_COMM_WORLD
         mpi_worlds[new_idx].comm=nextWorld;
-       if (mpi_nworlds<=new_idx) mpi_nworlds=new_idx+1;
+       if (_mpi_nworlds<=new_idx) _mpi_nworlds=new_idx+1;
        STARTUP_DEBUG("ampiInit> listed MPI_COMM_UNIVERSE "<<new_idx)
     }
 };
@@ -1662,7 +1662,7 @@ const ampiCommStruct &universeComm2CommStruct(MPI_Comm universeNo)
 {
   if (universeNo>MPI_COMM_WORLD) {
     int worldDex=universeNo-MPI_COMM_WORLD-1;
-    if (worldDex>=mpi_nworlds)
+    if (worldDex>=_mpi_nworlds)
       CkAbort("Bad world communicator passed to universeComm2CommStruct");
     return mpi_worlds[worldDex].comm;
   }
index d82ef4eb42c61f2ee8b4a40b183c56fa54f9e460..1796e90696770fa60c1c9686ec9ba19a914e3e8b 100644 (file)
@@ -216,7 +216,7 @@ inline MPI_Op & GET_MPI_OP(int idx)      { MPI_Op *tab=CtvAccess(mpi_ops); retur
 void mpi_init_universe(int *unicomm)
 {
   AMPIAPI("mpi_init_universe");
-  for(int i=0;i<mpi_nworlds; i++)
+  for(int i=0;i<_mpi_nworlds; i++)
   {
     unicomm[i] = MPI_COMM_UNIVERSE[i];
   }
index ab36765d0ba297479ec7466660156a22dd48cefd..f697be8160d382b4c2175a756b6ce85b60189449 100644 (file)
@@ -515,7 +515,7 @@ inline groupStruct rangeExclOp(int n, int ranges[][3], groupStruct vec){
 #include "charm-api.h"
 #include <sys/stat.h> // for mkdir
 
-extern int mpi_nworlds;
+extern int _mpi_nworlds;
 
 #define MPI_BCAST_TAG   MPI_TAG_UB_VALUE+10
 #define MPI_BARR_TAG    MPI_TAG_UB_VALUE+11
index d99bb1447cf4d6820ddb1468ff32ad4cb89ac1cf..34435959d3b72d56444ca842c2a3e0509bda6bd2 100644 (file)
@@ -358,6 +358,10 @@ TCharm::~TCharm()
 
 void TCharm::migrateTo(int destPE) {
        if (destPE==CkMyPe()) return;
+       if (CthMigratable() == 0) {
+           CkPrintf("Warning> thread migration is not supported!\n");
+            return;
+        }
        // Make sure migrateMe gets called *after* we suspend:
        thisProxy[thisIndex].migrateDelayed(destPE);
 //     resumeAfterMigration=true;
index ae301c5b5efdf0765a937ab45a8836fb09622a2e..062b02436d144a2975c6f62ffa382c91084425bf 100644 (file)
@@ -152,7 +152,7 @@ inline __veclf __vmaddlf(const __veclf a, const __veclf b, const __veclf c) { __
 /***** Reciprocal *****/
 /* TODO | FIXME  - See if there is a better way to do this (few cycles and avoid the memory load) */
 inline  __vecf  __vrecipf(const  __vecf a) {  __vecf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; r.v2 = 1.0f / a.v2; r.v3 = 1.0f / a.v3; return r; }
-inline __veclf __vreciplf(const __veclf a) { __veclf r; r.v0 = 1.0 / a.v0; r.v1 = 1.0 / a.v1; return r; }
+inline __veclf __vreciplf(const __veclf a) { __veclf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; return r; }
 
 /***** Square Root *****/
 inline  __vecf  __vsqrtf(const  __vecf a) {  __vecf r; r.v0 = sqrtf(a.v0); r.v1 = sqrtf(a.v1); r.v2 = sqrtf(a.v2); r.v3 = sqrtf(a.v3); return r; }
@@ -360,6 +360,7 @@ inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r
   inline  float  vextractf( vecf v, const int i) { return (( float*)(&v))[i]; }
   inline double vextractlf(veclf v, const int i) { return ((double*)(&v))[i]; }
 
+
   /***** Set *****/
   #define  vseti(a)  (_mm_set1_epi32((int)(a)))
   #define  vsetf(a)  (_mm_set1_ps((float)(a)))
@@ -418,7 +419,12 @@ inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r
 
   /***** Reciprocal *****/
   #define  vrecipf(a)  (_mm_rcp_ps(a))
-  #define vreciplf(a)  (_mm_rcp_pd(a))
+
+// why, oh why hath the SSE2 developers forsaken us?
+//  #define vreciplf(a)  (_mm_rcp_pd(a)) <-- no worky
+
+// vrecip goes to a not very vector implementation
+inline veclf vreciplf(const veclf a) { veclf r; double* a_ptr =  (double*)(&a); double* r_ptr = (double*)(&r); r_ptr[0] = 1.0f /  a_ptr[0]; r_ptr[1] = 1.0f / a_ptr[1]; return r; }
 
   /***** Square Root *****/
   #define  vsqrtf(a)  (_mm_sqrt_ps(a))
@@ -1111,6 +1117,10 @@ inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r
 #define  vspreadf(a)  ( vsetf(a))
 #define vspreadlf(a)  (vsetlf(a))
 
+#define visfinitef(a) ( isfinite(vextractf((a),0)) && isfinite(vextractf((a),1)) && isfinite(vextractf((a),2)) && isfinite(vextractf((a),3)))
+#define visfinitelf(a) (isfinite(vextractlf((a),0)) && isfinite(vextractlf((a),1)))
+
+
 /***** Add to Scalar *****/
 #define   vaddis(a, b)  ( vaddi((a),  vseti(b)))
 #define   vaddfs(a, b)  ( vaddf((a),  vsetf(b)))
index 4324db07209dc76fda4ca9d5c4fd6c3adf9e35be..a9bb885834d1b34728df2adbacce391d7f42c5a8 100644 (file)
@@ -1,4 +1,4 @@
-DIRS=megampi stacksize
+DIRS=megampi stacksize migration
 #DIRS=megampi stacksize chkpt 
 
 all:
diff --git a/tests/ampi/migration/Makefile b/tests/ampi/migration/Makefile
new file mode 100644 (file)
index 0000000..f84fe33
--- /dev/null
@@ -0,0 +1,32 @@
+CHARMC=../../../bin/ampicxx $(OPTS)
+
+all: pgm
+
+pgm: test.o
+       $(CHARMC) -o pgm test.o 
+
+test.o: test.C
+       $(CHARMC) -c test.C
+
+#
+#
+# clean up .o, .mod, .exe and EMACS backup files
+#
+clean:
+       rm -f *.o *.mod pgm *~ conv-host charmrun test.o
+
+test: pgm
+       ./charmrun ./pgm +p1 +vp1 $(TESTOPTS)
+       ./charmrun ./pgm +p1 +vp4 $(TESTOPTS)
+       ./charmrun ./pgm +p1 +vp20 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp1 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp4 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp20 $(TESTOPTS)
+
+bgtest: pgm
+       ./charmrun ./pgm +p1 +vp1 +x1 +y1 +z1 $(TESTOPTS)
+       ./charmrun ./pgm +p1 +vp2 +x1 +y1 +z1 $(TESTOPTS)
+       ./charmrun ./pgm +p1 +vp4 +x1 +y1 +z1 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp2 +x2 +y1 +z1 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp4 +x2 +y1 +z1 $(TESTOPTS)
+       ./charmrun ./pgm +p2 +vp1 +x2 +y1 +z1 $(TESTOPTS)
diff --git a/tests/ampi/migration/test.C b/tests/ampi/migration/test.C
new file mode 100644 (file)
index 0000000..dbe2a51
--- /dev/null
@@ -0,0 +1,63 @@
+/**
+ * AMPI Thread Migration Test
+ * Migrate the rank 1 AMPI process from node to node in order.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "mpi.h"
+#include "charm.h" /* For CkAbort */
+
+
+int main(int argc,char **argv)
+{
+
+  int rank;            /* process id */
+  int p;                /* number of processes */
+  
+  MPI_Init( &argc, &argv );
+  MPI_Comm_rank( MPI_COMM_WORLD, &rank);
+  MPI_Comm_size( MPI_COMM_WORLD, &p );
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  if(p >= 1){
+    CkPrintf("\nbegin migrating\n");
+
+    for (int step=0; step<=CkNumPes(); ++step) {
+      if (rank == 1) {
+       int destination_pe = (CkMyPe() + 1) % CkNumPes();
+       CkPrintf("Trying to migrate partition %d from pe %d to %d\n",
+                rank, CkMyPe(), destination_pe);
+       fflush(stdout);
+       CkAssert(destination_pe >= 0);
+       int migrate_test = CkMyPe();
+       printf("Entering TCHARM_Migrate_to, "
+               "FEM_My_partition is %d, "
+              "CkMyPe() is %d, migrate_test is %d\n",
+              rank, CkMyPe(), migrate_test);
+       fflush(stdout);
+       AMPI_Migrateto(destination_pe);
+       printf("Leaving TCHARM_Migrate_to, "
+               "FEM_My_partition is %d, "
+              "CkMyPe() is %d, migrate_test is %d\n",
+              rank, CkMyPe(), migrate_test);
+       fflush(stdout);
+      }
+
+      MPI_Barrier(MPI_COMM_WORLD);
+
+      CkPrintf("Done with step %d\n", step);
+      fflush(stdout);
+    }
+
+
+    MPI_Barrier(MPI_COMM_WORLD);
+    CkPrintf("done migrating\n");
+    MPI_Barrier(MPI_COMM_WORLD);
+
+  }
+
+  if (rank==0) CkPrintf("All tests passed\n");
+  MPI_Finalize();
+  return 0;
+}
index 237ab03619eba75a4534a7437c409217d2035a5f..dfd20ef724ef0509df21958809b1aeac12ee18d4 100644 (file)
@@ -185,3 +185,9 @@ callback.o: \
        megatest.h \
        callback.def.h
        $(CHARMC) -o callback.o callback.C
+inlineem.o: \
+       inlineem.C \
+       inlineem.decl.h \
+       megatest.h \
+       inlineem.def.h
+       $(CHARMC) -o inlineem.o inlineem.C
index 2e9000f5e6c280063650907d5db96c0c53cf82bd..8f999965d4183e51a5ac4cfba8563e7302c8645f 100644 (file)
@@ -29,6 +29,7 @@ OBJS=megatest.o \
      bitvector.o \
      immediatering.o \
      callback.o \
+     inlineem.o \
 
 
 #     priolongtest.o \
@@ -60,7 +61,8 @@ OBJS_REV=megatest.o \
      varraystest.o \
      varsizetest.o \
      nodering.o \
-     groupring.o
+     groupring.o \
+     inlineem.o
 
 #     priolongtest.o \
 
@@ -71,7 +73,7 @@ CIFILES =  \
       fib.def.h        megatest.def.h       priotest.def.h   tempotest.def.h  \
       groupcast.def.h  migration.def.h      queens.def.h     varraystest.def.h\
       groupring.def.h  nodecast.def.h       reduction.def.h  varsizetest.def.h\
-      groupsectiontest.def.h multisectiontest.def.h #priolongtest.def.h 
+      groupsectiontest.def.h multisectiontest.def.h inlineem.def.h #priolongtest.def.h
 
 .SUFFIXES:
 .SUFFIXES: .o .C .def.h .decl.h .ci .h
diff --git a/tests/charm++/megatest/inlineem.C b/tests/charm++/megatest/inlineem.C
new file mode 100644 (file)
index 0000000..3f6a883
--- /dev/null
@@ -0,0 +1,48 @@
+#include "inlineem.decl.h"
+#include "megatest.h"
+
+readonly<CProxy_inline_tester> t;
+
+void inlineem_moduleinit(void)
+{
+  CProxy_inline_group g = CProxy_inline_group::ckNew();
+  t = CProxy_inline_tester::ckNew(g);
+}
+
+void inlineem_init(void)
+{
+  ((CProxy_inline_tester)t).start_test();
+}
+
+struct inline_group : public CBase_inline_group
+{
+  bool called;
+  inline_group() : called(false) {}
+  void try_inline() {
+    called = true;
+  }
+};
+
+struct inline_tester : public CBase_inline_tester
+{
+  CProxy_inline_group g;
+  inline_tester(CProxy_inline_group g_) : g(g_) {}
+  void start_test()
+  {
+    inline_group *gl = g.ckLocalBranch();
+    if (gl->called)
+      CkAbort("Inline test was called already?\n");
+
+    g[CkMyPe()].try_inline();
+
+    if (!gl->called)
+      CkAbort("Inline test should have been called by now!\n");
+
+    gl->called = false;
+    megatest_finish();
+  }
+};
+
+MEGATEST_REGISTER_TEST(inlineem, "phil", 0)
+
+#include "inlineem.def.h"
diff --git a/tests/charm++/megatest/inlineem.ci b/tests/charm++/megatest/inlineem.ci
new file mode 100644 (file)
index 0000000..df00c1a
--- /dev/null
@@ -0,0 +1,13 @@
+module inlineem
+{
+  group inline_group
+  {
+    entry inline_group();
+    entry [inline] void try_inline();
+  }
+  chare inline_tester
+  {
+    entry inline_tester(CProxy_inline_group &);
+    entry void start_test();
+  }
+}