Added code for counting GFlops, modified code for force calculation, and other minor...
authorDavid Kunzman <kunzman2@illinois.edu>
Tue, 7 Apr 2009 05:35:45 +0000 (05:35 +0000)
committerDavid Kunzman <kunzman2@illinois.edu>
Tue, 7 Apr 2009 05:35:45 +0000 (05:35 +0000)
12 files changed:
examples/charm++/cell/md/main.C
examples/charm++/cell/md/main.h
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

index 4de0cfdf20d50f23029c9bb57b6aab565998f89e..d9c6b3b463994d3dc6e5a8807d3872190959afb1 100644 (file)
@@ -15,6 +15,12 @@ int numPatchesY;
 int numPatchesZ;
 
 
+// DMK - DEBUG
+#if COUNT_FLOPS != 0
+  unsigned long long int globalFlopCount;
+#endif
+
+
 void Main::parseCommandLine(int argc, char** argv) {
 
   // Verify the parameters
@@ -80,6 +86,15 @@ Main::Main(CkArgMsg* msg) {
     traceRegisterUserEvent("CmiMachineProgressImpl", PROJ_USER_EVENT_MACHINEPROGRESS);
   #endif
 
+  // DMK - DEBUG
+  #if COUNT_FLOPS != 0
+    globalFlopCount = 0;
+    if (CkNumPes() != 1) {
+      CkPrintf("ERROR: When COUNT_FLOPS is enabled, only a single processor should be used... Exiting...\n");
+      CkExit();
+    }
+  #endif
+
   // Spread a proxy to this main chare object to all processors via a read-only
   mainProxy = thisProxy;
 
@@ -155,6 +170,11 @@ void Main::patchCheckIn() {
       double simStopTime = CkWallTimer();
       CkPrintf("Elapsed Time: %lf sec\n", simStopTime - simStartTime);
 
+      // DMK - DEBUG
+      #if COUNT_FLOPS != 0
+        CkPrintf("Global Flop Count: %llu flops (%llu GFlops)\n", globalFlopCount, globalFlopCount / 1000000000);
+      #endif
+
       // The simulation has completed, so exit
       CkExit();
 
index 8bb653a0de951a5fd8c979707935c83c51a9baf2..913368d9cf26d636fa59a6518f81f95dd99014f8 100644 (file)
@@ -16,6 +16,12 @@ extern int numPatchesY;
 extern int numPatchesZ;
 
 
+// DMK - DEBUG
+#if COUNT_FLOPS != 0
+  extern unsigned long long int globalFlopCount;
+#endif
+
+
 class Main : public CBase_Main {
 
   private:
index 63f90210d487db8a20647e02829a852b0d586224..fe639551631f57a4429a9fcdf8f2332ed2c682d1 100644 (file)
@@ -41,6 +41,9 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Misc. Macros for Performance Testing
 
+// DMK - DEBUG
+#define COUNT_FLOPS                      (0)
+
 // DMK - DEBUG
 #define ENABLE_USER_EVENTS               (1)
 #define PROJ_USER_EVENT_PATCH_FORCECHECKIN_CALLBACK  (1120)
index 28ff50e04a73123eb646ac3d51cac0c9bf9424ab..903681e7412c36c0fd286f0910a1852a1c938522 100644 (file)
@@ -95,7 +95,25 @@ void PairCompute::patchData(int numParticles, float* particleX, float* particleY
   //   sent their data to this compute
   patchDataCount++;
   if (patchDataCount >= 2) {
-    thisProxy(thisIndex.x, thisIndex.y).doCalc();  // Send message to self to do calculation
+
+    // DMK - DEBUG - Call doCalc function locally instead of sending a message
+    #if CMK_CELL != 0 && 0
+      CkIndex_PairCompute::_accelCall_spe_doCalc_void(this->numParticles,
+                                                      this->thisIndex.x, this->thisIndex.y,
+                                                      this->particleX[0], this->particleX[1],
+                                                      this->particleY[0], this->particleY[1],
+                                                      this->particleZ[0], this->particleZ[1],
+                                                      this->particleQ[0], this->particleQ[1],
+                                                      this->forceX[0], this->forceX[0],
+                                                      this->forceY[0], this->forceY[0],
+                                                      this->forceZ[0], this->forceZ[0],
+                                                      this->localFlopCount,
+                                                      this
+                                                     );
+    #else
+      thisProxy(thisIndex.x, thisIndex.y).doCalc();  // Send message to self to do calculation
+    #endif
+
     patchDataCount = 0;
   }
 }
@@ -108,6 +126,11 @@ void PairCompute::doCalc_callback() {
     double __start_time__ = CmiWallTimer();
   #endif
 
+  // DMK - DEBUG
+  #if COUNT_FLOPS != 0
+    globalFlopCount += localFlopCount;
+  #endif
+
   #if USE_PROXY_PATCHES != 0
 
     (proxyPatchProxy[0].ckLocalBranch())->forceCheckIn(numParticles, forceX[0], forceY[0], forceZ[0]);
index a073dcb62e21b0d9573086ce886157dc476e9b9c..17babbc9c667eadafc24e2eb96f451db8166df01 100644 (file)
@@ -33,12 +33,18 @@ module pairCompute {
                                  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]>
+                                 writeonly : float f1_z[numParticles] <impl_obj->forceZ[1]>,
+                                 writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                ] {
 
       // Calculate the electrostatic force (coulumb's law) between the particles
       //   F = (k_e * (q_0 * q_1)) / (r^2)
 
+      // DMK - DEBUG
+      #if COUNT_FLOPS != 0
+        localFlopCount = 0;
+      #endif
+
       register vec4f* p1_x_vec = (vec4f*)p1_x;
       register vec4f* p1_y_vec = (vec4f*)p1_y;
       register vec4f* p1_z_vec = (vec4f*)p1_z;
@@ -101,6 +107,11 @@ module pairCompute {
         vec4f 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);
         vec4f r_vec = vsqrt4f(r_2_vec);
 
+        // DMK - DEBUG
+        #if COUNT_FLOPS != 0
+          localFlopCount += (9 * 4);
+        #endif
+
         // Setup Input for Stage 4 - Initially for j+0
         const int jPlus0 = 0;
         vec4f f_x_vec;
@@ -112,14 +123,20 @@ module pairCompute {
           vec4f p_z_diff_vec = p0_z_i_vec - p1_z_vec[jPlus0];
           vec4f 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);
           vec4f r_vec = vsqrt4f(r_2_vec);
-          vec4f p_x_diff_norm_vec = p_x_diff_vec / r_vec;
-          vec4f p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vec4f p_z_diff_norm_vec = p_z_diff_vec / r_vec;
-          vec4f p1_q_j_vec = p1_q_vec[jPlus0];
-          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) / r_2_vec);  // Calc force magnitude
+          vec4f r_recip_vec = vrecip4f(r_vec);
+          vec4f r_2_recip_vec = vrecip4f(r_2_vec);
+          vec4f p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          vec4f p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          vec4f p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          vec4f 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;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (23 * 4);
+          #endif
         }
 
         /// Main Loop ///
@@ -135,13 +152,15 @@ module pairCompute {
           f1_z_vec[j] -= f_z_vec;
 
           // Stage 3 - Calculate force vector
-          vec4f p_x_diff_norm_vec = p_x_diff_vec / r_vec;  // Normalize the vector between the particles
-          vec4f p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vec4f p_z_diff_norm_vec = p_z_diff_vec / r_vec;
-          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec_s2) / r_2_vec);  // Calc force magnitude
-          vec4f f_x_vec = p_x_diff_norm_vec * f_mag_vec;  // Multiply normalized vector by force magnitude
-          vec4f f_y_vec = p_y_diff_norm_vec * f_mag_vec;
-          vec4f f_z_vec = p_z_diff_norm_vec * f_mag_vec;
+          vec4f r_recip_vec = vrecip4f(r_vec);
+          vec4f r_2_recip_vec = vrecip4f(r_2_vec);
+          vec4f p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          vec4f p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          vec4f p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          vec4f 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;
 
           // Stage 2 - Calculate radius
           p1_q_j_vec_s2 = p1_q_j_vec;
@@ -157,6 +176,12 @@ module pairCompute {
           p1_y_j_vec = p1_y_vec[jIndexToLoad];
           p1_z_j_vec = p1_z_vec[jIndexToLoad];
           p1_q_j_vec = p1_q_vec[jIndexToLoad];
+
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (31 * 4);
+          #endif
         }
 
         /// Loop Cleanup ///
@@ -169,14 +194,21 @@ module pairCompute {
           f1_x_vec[loopUpper] -= f_x_vec;
           f1_y_vec[loopUpper] -= f_y_vec;
           f1_z_vec[loopUpper] -= f_z_vec;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (6 * 4);
+          #endif
         }
 
         // Complete Calc for Stage 2 Data - Calculate Force Vector, Apply Force Vector
         {
-          vec4f p_x_diff_norm_vec = p_x_diff_vec / r_vec;
-          vec4f p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vec4f p_z_diff_norm_vec = p_z_diff_vec / r_vec;
-          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec_s2) / r_2_vec);
+          vec4f r_recip_vec = vrecip4f(r_vec);
+          vec4f r_2_recip_vec = vrecip4f(r_2_vec);
+          vec4f p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          vec4f p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          vec4f p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec_s2) * r_2_recip_vec);
           vec4f f_x_vec = p_x_diff_norm_vec * f_mag_vec;
           vec4f f_y_vec = p_y_diff_norm_vec * f_mag_vec;
           vec4f f_z_vec = p_z_diff_norm_vec * f_mag_vec;
@@ -186,6 +218,11 @@ module pairCompute {
           f1_x_vec[loopUpper + 1] -= f_x_vec;
           f1_y_vec[loopUpper + 1] -= f_y_vec;
           f1_z_vec[loopUpper + 1] -= f_z_vec;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (19 * 4);
+          #endif
         }
 
         // Complete Calc for Stage 1 Data - Calculate Radius, Calculate Force Vector, Apply Force Vector
@@ -195,10 +232,12 @@ module pairCompute {
           vec4f p_z_diff_vec = p0_z_i_vec - p1_z_j_vec;
           vec4f 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);
           vec4f r_vec = vsqrt4f(r_2_vec);
-          vec4f p_x_diff_norm_vec = p_x_diff_vec / r_vec;
-          vec4f p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vec4f p_z_diff_norm_vec = p_z_diff_vec / r_vec;
-          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) / r_2_vec);
+          vec4f r_recip_vec = vrecip4f(r_vec);
+          vec4f r_2_recip_vec = vrecip4f(r_2_vec);
+          vec4f p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          vec4f p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          vec4f p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p1_q_j_vec) * r_2_recip_vec);
           vec4f f_x_vec = p_x_diff_norm_vec * f_mag_vec;
           vec4f f_y_vec = p_y_diff_norm_vec * f_mag_vec;
           vec4f f_z_vec = p_z_diff_norm_vec * f_mag_vec;
@@ -208,6 +247,11 @@ module pairCompute {
           f1_x_vec[loopUpper + 2] -= f_x_vec;
           f1_y_vec[loopUpper + 2] -= f_y_vec;
           f1_z_vec[loopUpper + 2] -= f_z_vec;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (27 * 4);
+          #endif
         }
 
         #else
@@ -254,6 +298,12 @@ module pairCompute {
           f1_x_vec[j] -= f_x_vec;
           f1_y_vec[j] -= f_y_vec;
           f1_z_vec[j] -= f_z_vec;
+
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (24 * 4);
+          #endif
         }
 
         #endif
index 0cf03a1f4f2e842a3f83667fa1902e95236d967a..b6f3729640b08354d16a0e10d8da67f473ee1885 100644 (file)
@@ -33,6 +33,9 @@ class PairCompute : public CBase_PairCompute {
       CProxy_ProxyPatch proxyPatchProxy[2];
     #endif
 
+    // DMK - DEBUG
+    unsigned int localFlopCount;
+
   public:
 
     /// Constructor(s) \ Destructor ///
index 5a487e412827be4285b990e74d1dc4e647d20d08..8235234ef5bbf097ce7d89ba39036a5098213a9b 100644 (file)
@@ -124,16 +124,22 @@ void Patch::startIteration_common(int numIters) {
   remainingForceCheckIns = numPatchesX * numPatchesY * numPatchesZ;
 
   // Clear the force sum arrays
-  register vec4f* fsx = (vec4f*)forceSumX;
-  register vec4f* fsy = (vec4f*)forceSumY;
-  register vec4f* fsz = (vec4f*)forceSumZ;
-  const vec4f zero_vec = vspread4f(0.0f);
-  register const int numParticles_vec = numParticles / (sizeof(vec4f) * sizeof(float));
-  for (int i = 0; i < numParticles_vec; i++) {
-    fsx[i] = zero_vec;
-    fsy[i] = zero_vec;
-    fsz[i] = zero_vec;
-  }
+  #if 1
+    memset(forceSumX, 0, sizeof(float) * numParticles);
+    memset(forceSumY, 0, sizeof(float) * numParticles);
+    memset(forceSumZ, 0, sizeof(float) * numParticles);
+  #else
+    register vec4f* fsx = (vec4f*)forceSumX;
+    register vec4f* fsy = (vec4f*)forceSumY;
+    register vec4f* fsz = (vec4f*)forceSumZ;
+    const vec4f zero_vec = vspread4f(0.0f);
+    register const int numParticles_vec = numParticles / (sizeof(vec4f) * sizeof(float));
+    for (int i = 0; i < numParticles_vec; i++) {
+      fsx[i] = zero_vec;
+      fsy[i] = zero_vec;
+      fsz[i] = zero_vec;
+    }
+  #endif
 
   // DMK - DEBUG
   NetworkProgress
@@ -224,6 +230,11 @@ void Patch::integrate_callback() {
     double __start_time__ = CmiWallTimer();
   #endif
 
+  // DMK - DEBUG
+  #if COUNT_FLOPS != 0
+    globalFlopCount += localFlopCount;
+  #endif
+
   // DMK - DEBUG
   NetworkProgress
 
@@ -340,7 +351,7 @@ void ProxyPatch::patchData(int numParticles, float* particleX, float* particleY,
 void ProxyPatch::forceCheckIn(int numParticles, float* forceX, float* forceY, float* forceZ) {
 
   // Accumulate the force data
-  #if 0
+  #if USE_PROXY_PATCHES != 0  // Calls will be local and pointers will be aligned, so take advantage and vectorize the code
     register vec4f* forceX_vec = (vec4f*)forceX;
     register vec4f* forceY_vec = (vec4f*)forceY;
     register vec4f* forceZ_vec = (vec4f*)forceZ;
index bc298acf9dbff883ca27653ce7318fb949e980f2..032f77bc5da0742b6fbd49c3edaafe967513d369 100644 (file)
@@ -58,9 +58,15 @@ module patch {
                                     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 : float v_z[numParticles] <impl_obj->velocityZ>,
+                                   writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                   ] {
 
+      // DMK - DEBUG
+      #if COUNT_FLOPS != 0
+        localFlopCount = 0;
+      #endif
+
       register vec4f* p_x_vec = (vec4f*)p_x;
       register vec4f* p_y_vec = (vec4f*)p_y;
       register vec4f* p_z_vec = (vec4f*)p_z;
@@ -91,6 +97,11 @@ module patch {
         p_x_vec[i] += delta_time_vec * new_v_x_vec;
         p_y_vec[i] += delta_time_vec * new_v_y_vec;
         p_z_vec[i] += delta_time_vec * new_v_z_vec;
+
+        // DMK - DEBUG
+        #if COUNT_FLOPS != 0
+          localFlopCount += (15 * 4);
+        #endif
       }
 
     } integrate_callback;
index 5acc86a1c41c11dfde5d3594c0a2c390dc07d75b..5cdc8e77a75d38eab4ec04d957799f2318b473c6 100644 (file)
@@ -42,6 +42,11 @@ class Patch : public CBase_Patch {
       int* proxyPatchPresentFlags;
     #endif
 
+
+    // DMK - DEBUG
+    unsigned int localFlopCount;
+
+
     /// Member Functions ///
     void randomizeParticles();
     float randf();
index 9a3f679da154a5c791fa4e09d7c26cdf88ff6a06..8322638d29f6d83c70d0a246bbc1631bf6deef6e 100644 (file)
@@ -86,6 +86,11 @@ void SelfCompute::doCalc_callback() {
     double __start_time__ = CmiWallTimer();
   #endif
 
+  // DMK - DEBUG
+  #if COUNT_FLOPS != 0
+    globalFlopCount += localFlopCount;
+  #endif
+
   // DMK - DEBUG
   NetworkProgress;
 
index 61219af15944144cee10a54b10a9ee215cc7feb9..3896f3bcb38d00a080d43f1c5a8e3249484cd752 100644 (file)
@@ -26,12 +26,18 @@ module selfCompute {
                                  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>
+                                writeonly : float f0_z[numParticles] <impl_obj->forceZ>,
+                                writeonly : unsigned int localFlopCount <impl_obj->localFlopCount>
                                ] {
 
       // Calculate the electrostatic force (coulumb's law) between the particles
       //   F = (k_e * (q_0 * q_1)) / (r^2)
 
+      // DMK - DEBUG
+      #if COUNT_FLOPS != 0
+        localFlopCount = 0;
+      #endif
+
       register vec4f* p0_x_vec = (vec4f*)particleX;
       register vec4f* p0_y_vec = (vec4f*)particleY;
       register vec4f* p0_z_vec = (vec4f*)particleZ;
@@ -82,6 +88,11 @@ module selfCompute {
           f0_x[j] -= f_x;
           f0_y[j] -= f_y;
           f0_z[j] -= f_z;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += 26;
+          #endif
         }
 
         // Spread this particle's (p0[i]) values out over vectors
@@ -108,19 +119,16 @@ module selfCompute {
           vec4f p_z_diff_vec = p0_z_i_vec - p0_z_j_vec;
 
           // Calculate r and r^2 between the particles
-          vec4f p_x_diff_2_vec = p_x_diff_vec * p_x_diff_vec;
-          vec4f p_y_diff_2_vec = p_y_diff_vec * p_y_diff_vec;
-          vec4f p_z_diff_2_vec = p_z_diff_vec * p_z_diff_vec;
-          vec4f r_2_vec = p_x_diff_2_vec + p_y_diff_2_vec + p_z_diff_2_vec;
+          vec4f 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);
           vec4f r_vec = vsqrt4f(r_2_vec);
 
           // Normalize the vector between the particles
-          vec4f p_x_diff_norm_vec = p_x_diff_vec / r_vec;
-          vec4f p_y_diff_norm_vec = p_y_diff_vec / r_vec;
-          vec4f p_z_diff_norm_vec = p_z_diff_vec / r_vec;
-
-          // Calculate the magnitude of the electrostatic force between the particles
-          vec4f f_mag_vec = coulomb_vec * ((p0_q_i_vec * p0_q_j_vec) / r_2_vec);
+          vec4f r_recip_vec = vrecip4f(r_vec);
+          vec4f r_2_recip_vec = vrecip4f(r_2_vec);
+          vec4f p_x_diff_norm_vec = p_x_diff_vec * r_recip_vec;
+          vec4f p_y_diff_norm_vec = p_y_diff_vec * r_recip_vec;
+          vec4f p_z_diff_norm_vec = p_z_diff_vec * r_recip_vec;
+          vec4f 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
@@ -135,6 +143,11 @@ module selfCompute {
           f0_x_vec[j] -= f_x_vec;
           f0_y_vec[j] -= f_y_vec;
           f0_z_vec[j] -= f_z_vec;
+
+          // DMK - DEBUG
+          #if COUNT_FLOPS != 0
+            localFlopCount += (31 * 4);
+          #endif
         }
 
         // Add force values for p0[i] into f0
index 660d453ab895b12a94103db2a84172702d93894d..bea380921b69010e21cbee0ea639a7c4fa7e5926 100644 (file)
@@ -27,6 +27,11 @@ class SelfCompute : public CBase_SelfCompute {
 
     CProxy_ProxyPatch proxyPatchProxy;
 
+
+    // DMK - DEBUG
+    unsigned int localFlopCount;
+
+
   public:
 
     /// Constructor(s) \ Destructor ///