Add some benchmarks

benchmarks/README

@@ -0,0 +1,14 @@
+Running Benchmarks
+------------------
+
+Under SpiderMonkey:
+
+  $ cp ../src/memory.js .
+  $ js -n -m ../src/ljc.js -l <bench>.ljs
+  $ js -n -m <bench>.js
+
+Under Node:
+
+  $ export NODE_PATH="../src:$NODE_PATH"
+  $ ../bin/ljc <bench>.ljs
+  $ node <bench>.js

benchmarks/access-nbody.ljs

@@ -0,0 +1,211 @@
+/* The Great Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy */
+
+typedef byte *malloc_ty(uint);
+let malloc_ty malloc;
+if (typeof require !== "undefined") {
+  malloc = (malloc_ty)(require('memory').malloc);
+} else {
+  extern memory;
+  malloc = (malloc_ty)(memory.malloc);
+}
+
+struct Body {
+  double x, y, z, vx, vy, vz, mass;
+};
+
+const double PI = 3.141592653589793;
+const double SOLAR_MASS = 4 * PI * PI;
+const double DAYS_PER_YEAR = 365.24;
+
+function setBody(Body *b,
+                 double x, double y, double z,
+                 double vx, double vy, double vz,
+                 double mass) {
+  b->x = x;
+  b->y = y;
+  b->z = z;
+  b->vx = vx;
+  b->vy = vy;
+  b->vz = vz;
+  b->mass = mass;
+}
+
+function setJupiter(Body *b) {
+  setBody(b,
+          4.84143144246472090e+00,
+          -1.16032004402742839e+00,
+          -1.03622044471123109e-01,
+          1.66007664274403694e-03 * DAYS_PER_YEAR,
+          7.69901118419740425e-03 * DAYS_PER_YEAR,
+          -6.90460016972063023e-05 * DAYS_PER_YEAR,
+          9.54791938424326609e-04 * SOLAR_MASS);
+}
+
+function setSaturn(Body *b) {
+  setBody(b,
+          8.34336671824457987e+00,
+          4.12479856412430479e+00,
+          -4.03523417114321381e-01,
+          -2.76742510726862411e-03 * DAYS_PER_YEAR,
+          4.99852801234917238e-03 * DAYS_PER_YEAR,
+          2.30417297573763929e-05 * DAYS_PER_YEAR,
+          2.85885980666130812e-04 * SOLAR_MASS);
+}
+
+function setUranus(Body *b) {
+  setBody(b,
+          1.28943695621391310e+01,
+          -1.51111514016986312e+01,
+          -2.23307578892655734e-01,
+          2.96460137564761618e-03 * DAYS_PER_YEAR,
+          2.37847173959480950e-03 * DAYS_PER_YEAR,
+          -2.96589568540237556e-05 * DAYS_PER_YEAR,
+          4.36624404335156298e-05 * SOLAR_MASS);
+}
+
+function setNeptune(Body *b) {
+  setBody(b,
+          1.53796971148509165e+01,
+          -2.59193146099879641e+01,
+          1.79258772950371181e-01,
+          2.68067772490389322e-03 * DAYS_PER_YEAR,
+          1.62824170038242295e-03 * DAYS_PER_YEAR,
+          -9.51592254519715870e-05 * DAYS_PER_YEAR,
+          5.15138902046611451e-05 * SOLAR_MASS);
+}
+
+function setSun(Body *b) {
+  setBody(b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, SOLAR_MASS);
+}
+
+function Body *offsetMomentum(Body *b, double px, double py, double pz) {
+  b->vx = -px / SOLAR_MASS;
+  b->vy = -py / SOLAR_MASS;
+  b->vz = -pz / SOLAR_MASS;
+  return b;
+}
+
+const int NBODIES = 5;
+
+function NBodySystem() {
+  let Body *bodies = (Body *)(malloc(sizeof(Body) * NBODIES));
+
+  setSun(bodies);
+  setJupiter(bodies + 1);
+  setSaturn(bodies + 2);
+  setUranus(bodies + 3);
+  setNeptune(bodies + 4);
+
+  let double px = 0.0;
+  let double py = 0.0;
+  let double pz = 0.0;
+  for (let int i = 0; i < NBODIES; ++i) {
+    let Body *b = bodies + i;
+    let double mass = b->mass;
+    px += b->vx * mass;
+    py += b->vy * mass;
+    pz += b->vz * mass;
+  }
+  offsetMomentum(bodies, px, py, pz);
+
+  this.bodies = bodies;
+}
+
+extern Math;
+
+NBodySystem.prototype = {
+  advance: function advance(double dt) {
+    let double dx, dy, dz, distance, mag;
+    let Body *bodies = (Body *)(this->bodies);
+
+    for (let int i = 0; i < NBODIES; ++i) {
+      let Body *bi = bodies + i;
+      for (let int j = i + 1; j < NBODIES; ++j) {
+        let Body *bj = bodies + j;
+        dx = bi->x - bj->x;
+        dy = bi->y - bj->y;
+        dz = bi->z - bj->z;
+        distance = (double)(Math.sqrt(dx * dx + dy * dy + dz * dz));
+        mag = dt / (distance * distance * distance);
+
+        bi->vx -= dx * bj->mass * mag;
+        bi->vy -= dy * bj->mass * mag;
+        bi->vz -= dz * bj->mass * mag;
+
+        bj->vx += dx * bi->mass * mag;
+        bj->vy += dy * bi->mass * mag;
+        bj->vz += dz * bi->mass * mag;
+      }
+    }
+
+    for (let int i = 0; i < NBODIES; ++i) {
+      let Body *b = bodies + i;
+      b->x += dt * b->vx;
+      b->y += dt * b->vy;
+      b->z += dt * b->vz;
+    }
+  },
+
+  energy: function double energy() {
+    let double dx, dy, dz, distance;
+    let double e = 0.0;
+    let Body *bodies = (Body *)(this->bodies);
+
+    for (let int i = 0; i < NBODIES; ++i) {
+      let Body *bi = bodies + i;
+
+      e += 0.5 * bi->mass * (bi->vx * bi->vx +
+                             bi->vy * bi->vy +
+                             bi->vz * bi->vz);
+
+      for (let int j = i + 1; j < NBODIES; ++j) {
+        let Body *bj = bodies + j;
+        dx = bi->x - bj->x;
+        dy = bi->y - bj->y;
+        dz = bi->z - bj->z;
+
+        distance = (double)(Math.sqrt(dx * dx + dy * dy + dz * dz));
+
+        e -= (bi->mass * bj->mass) / distance;
+      }
+    }
+
+    return e;
+  }
+};
+
+extern print;
+if (typeof print === "undefined") {
+  extern console;
+  print = console.log;
+}
+
+function double run() {
+  let double res;
+
+  for (let int n = 3; n <= 24; n *= 2) {
+    let bodies = new NBodySystem();
+    let int max = n * 100;
+
+    for (let int i = 0; i < max; ++i) {
+      bodies.advance(0.01);
+    }
+    res = (double)(bodies.energy());
+    print("" + n + "=" + res);
+  }
+
+  return res;
+}
+
+extern Date;
+
+let start = new Date();
+let res = run();
+let elapsed = new Date() - start;
+
+if (res - (-0.1690693) < 0.00001)
+   print("metric time " + elapsed);
+else
+   print("error nbody result expecting -0.1690693 got " + res);