Trace for pic

tmp_before.cpp → tmp_after.cpp RENAMED Viewed

@@ -524,78 +524,73 @@ int main() {
           double rY0 = (((p->pos).y - (iY0 * cellY)) / cellY);
           int iZ0 = int_of_double(((p->pos).z / cellZ));
           double rZ0 = (((p->pos).z - (iZ0 * cellZ)) / cellZ);
           double_nbCorners coeffs;
           for (int k = 0; (k < nbCorners); k++) {
             coeffs.v[k] = (((coefX0[k] + (signX0[k] * rX0)) *
                             (coefY0[k] + (signY0[k] * rY0))) *
                            (coefZ0[k] + (signZ0[k] * rZ0)));
           }
           vect fieldAtPos = {0., 0., 0.};
-          fieldAtPos.x = (fieldAtPos.x +
-                          (((((((((coeffs.v)[0] * field_at_corners.v[0].x) +
-                                 ((coeffs.v)[1] * field_at_corners.v[1].x)) +
-                                ((coeffs.v)[2] * field_at_corners.v[2].x)) +
-                               ((coeffs.v)[3] * field_at_corners.v[3].x)) +
-                              ((coeffs.v)[4] * field_at_corners.v[4].x)) +
-                             ((coeffs.v)[5] * field_at_corners.v[5].x)) +
-                            ((coeffs.v)[6] * field_at_corners.v[6].x)) +
-                           ((coeffs.v)[7] * field_at_corners.v[7].x)));
-          fieldAtPos.y = (fieldAtPos.y +
-                          (((((((((coeffs.v)[0] * field_at_corners.v[0].y) +
-                                 ((coeffs.v)[1] * field_at_corners.v[1].y)) +
-                                ((coeffs.v)[2] * field_at_corners.v[2].y)) +
-                               ((coeffs.v)[3] * field_at_corners.v[3].y)) +
-                              ((coeffs.v)[4] * field_at_corners.v[4].y)) +
-                             ((coeffs.v)[5] * field_at_corners.v[5].y)) +
-                            ((coeffs.v)[6] * field_at_corners.v[6].y)) +
-                           ((coeffs.v)[7] * field_at_corners.v[7].y)));
-          fieldAtPos.z = (fieldAtPos.z +
-                          (((((((((coeffs.v)[0] * field_at_corners.v[0].z) +
-                                 ((coeffs.v)[1] * field_at_corners.v[1].z)) +
-                                ((coeffs.v)[2] * field_at_corners.v[2].z)) +
-                               ((coeffs.v)[3] * field_at_corners.v[3].z)) +
-                              ((coeffs.v)[4] * field_at_corners.v[4].z)) +
-                             ((coeffs.v)[5] * field_at_corners.v[5].z)) +
-                            ((coeffs.v)[6] * field_at_corners.v[6].z)) +
-                           ((coeffs.v)[7] * field_at_corners.v[7].z)));
           vect accel = {((particleCharge / particleMass) * fieldAtPos.x),
                         ((particleCharge / particleMass) * fieldAtPos.y),
                         ((particleCharge / particleMass) * fieldAtPos.z)};
           (p->speed).x = ((p->speed).x + (stepDuration * accel.x));
           (p->speed).y = ((p->speed).y + (stepDuration * accel.y));
           (p->speed).z = ((p->speed).z + (stepDuration * accel.z));
           (p->pos).x = ((p->pos).x + (stepDuration * (p->speed).x));
           (p->pos).y = ((p->pos).y + (stepDuration * (p->speed).y));
           (p->pos).z = ((p->pos).z + (stepDuration * (p->speed).z));
           particle p2 = {(p->pos), (p->speed)};
           int iX2 = int_of_double(((p->pos).x / cellX));
           int iY2 = int_of_double(((p->pos).y / cellY));
           int iZ2 = int_of_double(((p->pos).z / cellZ));
           int idCell2 = cellOfCoord(iX2, iY2, iZ2);
           bag_push((&bagsNext[idCell2]), p2);
           double rX1 = (((p->pos).x - (iX2 * cellX)) / cellX);
           double rY1 = (((p->pos).y - (iY2 * cellY)) / cellY);
           double rZ1 = (((p->pos).z - (iZ2 * cellZ)) / cellZ);
           double_nbCorners coeffs2;
-          for (int k = 0; (k < nbCorners); k++) {
-            coeffs2.v[k] = (((coefX0[k] + (signX0[k] * rX1)) *
-                             (coefY0[k] + (signY0[k] * rY1))) *
-                            (coefZ0[k] + (signZ0[k] * rZ1)));
-          }
           double_nbCorners deltaChargeOnCorners;
-          for (int k = 0; (k < nbCorners); k++) {
-            deltaChargeOnCorners.v[k] = (particleCharge * (coeffs2.v)[k]);
-          }
           const int_nbCorners indices = indicesOfCorners(idCell2);
           for (int k = 0; (k < nbCorners); k++) {
-            nextCharge[indices.v[k]] += deltaChargeOnCorners.v[k];
           }
         }
       }
       bag_init_initial(b);
     }
     for (int idCell = 0; (idCell < nbCells); idCell++) {
       bag_swap((&bagsCur[idCell]), (&bagsNext[idCell]));
     }
   }
 }

           double rY0 = (((p->pos).y - (iY0 * cellY)) / cellY);
           int iZ0 = int_of_double(((p->pos).z / cellZ));
           double rZ0 = (((p->pos).z - (iZ0 * cellZ)) / cellZ);
           double_nbCorners coeffs;
           for (int k = 0; (k < nbCorners); k++) {
             coeffs.v[k] = (((coefX0[k] + (signX0[k] * rX0)) *
                             (coefY0[k] + (signY0[k] * rY0))) *
                            (coefZ0[k] + (signZ0[k] * rZ0)));
           }
           vect fieldAtPos = {0., 0., 0.};
+          fieldAtPos.x =
+              (fieldAtPos.x + ((((((((coeffs.v[0] * field_at_corners.v[0].x) +
+                                     (coeffs.v[1] * field_at_corners.v[1].x)) +
+                                    (coeffs.v[2] * field_at_corners.v[2].x)) +
+                                   (coeffs.v[3] * field_at_corners.v[3].x)) +
+                                  (coeffs.v[4] * field_at_corners.v[4].x)) +
+                                 (coeffs.v[5] * field_at_corners.v[5].x)) +
+                                (coeffs.v[6] * field_at_corners.v[6].x)) +
+                               (coeffs.v[7] * field_at_corners.v[7].x)));
+          fieldAtPos.y =
+              (fieldAtPos.y + ((((((((coeffs.v[0] * field_at_corners.v[0].y) +
+                                     (coeffs.v[1] * field_at_corners.v[1].y)) +
+                                    (coeffs.v[2] * field_at_corners.v[2].y)) +
+                                   (coeffs.v[3] * field_at_corners.v[3].y)) +
+                                  (coeffs.v[4] * field_at_corners.v[4].y)) +
+                                 (coeffs.v[5] * field_at_corners.v[5].y)) +
+                                (coeffs.v[6] * field_at_corners.v[6].y)) +
+                               (coeffs.v[7] * field_at_corners.v[7].y)));
+          fieldAtPos.z =
+              (fieldAtPos.z + ((((((((coeffs.v[0] * field_at_corners.v[0].z) +
+                                     (coeffs.v[1] * field_at_corners.v[1].z)) +
+                                    (coeffs.v[2] * field_at_corners.v[2].z)) +
+                                   (coeffs.v[3] * field_at_corners.v[3].z)) +
+                                  (coeffs.v[4] * field_at_corners.v[4].z)) +
+                                 (coeffs.v[5] * field_at_corners.v[5].z)) +
+                                (coeffs.v[6] * field_at_corners.v[6].z)) +
+                               (coeffs.v[7] * field_at_corners.v[7].z)));
           vect accel = {((particleCharge / particleMass) * fieldAtPos.x),
                         ((particleCharge / particleMass) * fieldAtPos.y),
                         ((particleCharge / particleMass) * fieldAtPos.z)};
           (p->speed).x = ((p->speed).x + (stepDuration * accel.x));
           (p->speed).y = ((p->speed).y + (stepDuration * accel.y));
           (p->speed).z = ((p->speed).z + (stepDuration * accel.z));
           (p->pos).x = ((p->pos).x + (stepDuration * (p->speed).x));
           (p->pos).y = ((p->pos).y + (stepDuration * (p->speed).y));
           (p->pos).z = ((p->pos).z + (stepDuration * (p->speed).z));
           particle p2 = {(p->pos), (p->speed)};
           int iX2 = int_of_double(((p->pos).x / cellX));
           int iY2 = int_of_double(((p->pos).y / cellY));
           int iZ2 = int_of_double(((p->pos).z / cellZ));
           int idCell2 = cellOfCoord(iX2, iY2, iZ2);
           bag_push((&bagsNext[idCell2]), p2);
           double rX1 = (((p->pos).x - (iX2 * cellX)) / cellX);
           double rY1 = (((p->pos).y - (iY2 * cellY)) / cellY);
           double rZ1 = (((p->pos).z - (iZ2 * cellZ)) / cellZ);
           double_nbCorners coeffs2;
           double_nbCorners deltaChargeOnCorners;
           const int_nbCorners indices = indicesOfCorners(idCell2);
           for (int k = 0; (k < nbCorners); k++) {
+            nextCharge[indices.v[k]] +=
+                (particleCharge * (((coefX0[k] + (signX0[k] * rX1)) *
+                                    (coefY0[k] + (signY0[k] * rY1))) *
+                                   (coefZ0[k] + (signZ0[k] * rZ1))));
           }
         }
       }
       bag_init_initial(b);
     }
     for (int idCell = 0; (idCell < nbCells); idCell++) {
       bag_swap((&bagsCur[idCell]), (&bagsNext[idCell]));
     }
   }
 }

​x
 
#include <stdlib.h>
​
#include "optitrust.h"
​
#include <stdio.h>
​
typedef struct {
  double x;
  double y;
  double z;
} vect;
​
typedef struct {
  vect pos;
  vect speed;
} particle;
​
vect vect_add(vect v1, vect v2) {
  return {(v1.x + v2.x), (v1.y + v2.y), (v1.z + v2.z)};
}
​
vect vect_mul(double d, vect v) { return {(d * v.x), (d * v.y), (d * v.z)}; }
​
const int CHUNK_SIZE = 128;
​
typedef struct chunk {
  chunk *next;
  int size;
  particle items[CHUNK_SIZE];
} chunk;
​
typedef struct {
  chunk *front;
  chunk *back;
} bag;
​
chunk *atomic_read(chunk **p) {
  chunk *value;
  value = (*p);
  return value;
}
​
chunk *chunk_alloc() { return (chunk *)malloc(sizeof(chunk)); }
​
void chunk_free(chunk *c) { free(c); }
​
void bag_init(bag *b, int id_bag, int id_cell) {
  chunk *c = chunk_alloc();
  (c->size) = 0;