C vs Go at WSL1 (Ubuntu 20.04)

00-terminal.txt

NOTE: linux environment is WSL1 on Windows10

# based benchmark code: n-body (added little modifications by ryo_grid for excecuting same logic)
https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/nbody-gcc-3.html
https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/nbody-go-3.html


ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ uname -a
Linux DESKTOP-IOASPN6 4.4.0-19041-Microsoft #1237-Microsoft Sat Sep 11 14:32:00 PST 2021 x86_64 x86_64 x86_64 GNU/Linux

ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ gcc-11 --version
gcc-11 (Ubuntu 11.4.0-2ubuntu1~20.04) 11.4.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ go version
go version go1.20.7 linux/amd64

ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ gcc-11 -O5 nbody.c -o nbody.c.gcc11.out -lm -fomit-frame-pointer -static
ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ time ./nbody.c.gcc11.out 50000000
-0.169075164
-0.169059907

real    0m6.518s
user    0m6.516s
sys     0m0.000s

ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ go build -o nbody.go.gc.out nbody.go
ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ time ./nbody.go.gc.out 50000000
-0.169075164
-0.169059907

real    0m4.333s
user    0m4.313s
sys     0m0.016s

// additional evaluation with clang-11
ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ clang-11 --version
Ubuntu clang version 11.0.0-2~ubuntu20.04.1
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ clang-11 -O3 nbody.c -o nbody.c.clang11.out -lm -fomit-frame-pointer -static
ryo@DESKTOP-IOASPN6:/mnt/c/Data/work/go-bench$ time ./nbody.c.clang11.out 50000000
-0.169075164
-0.169059907

real    0m4.973s
user    0m4.953s
sys     0m0.000s

nbody.c

/* The Computer Language Benchmarks Game
 * https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
 *
 * contributed by Ledrug Katz
 *
 *   compile: gcc -Wall -O3 -fomit-frame-pointer -lm -mfpmath=sse
*/

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define pi 3.141592653589793
#define solar_mass (4 * pi * pi)
#define year 365.24
#define for_k for(k = 0; k < 3; k++)

typedef struct planet { double x[3], v[3], mass; } planet;


struct planet bodies[] = {
   {   /* sun */
      {0, 0, 0},
      {0, 0, 0},
      solar_mass
   }, {   /* jupiter */
      { 4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01 },
      {
         1.66007664274403694e-03 * year,
         7.69901118419740425e-03 * year,
         -6.90460016972063023e-05 * year
      },
      9.54791938424326609e-04 * solar_mass
   }, {   /* saturn */
      { 8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01 },
      {
         -2.76742510726862411e-03 * year,
         4.99852801234917238e-03 * year,
         2.30417297573763929e-05 * year
      },
      2.85885980666130812e-04 * solar_mass
   }, {   /* uranus */
      { 1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01 },
      {
         2.96460137564761618e-03 * year,
         2.37847173959480950e-03 * year,
         -2.96589568540237556e-05 * year
      },
      4.36624404335156298e-05 * solar_mass
   }, {   /* neptune */
      { 1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01 },
      {
         2.68067772490389322e-03 * year,
         1.62824170038242295e-03 * year,
         -9.51592254519715870e-05 * year
      },
      5.15138902046611451e-05 * solar_mass
   }
};

int N;

void advance(double dt, int steps)
{
   int i, j;
   register planet *a, *b;
   double d[3], d2, mag;

   while (steps--) {
      for (a = bodies, i = 0; i < N; a++, i++) {
         for (b = a + 1, j = i + 1; j < N; b++, j++) {
            d[0] = a->x[0] - b->x[0];
            d[1] = a->x[1] - b->x[1];
            d[2] = a->x[2] - b->x[2];

            d2 = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
            mag = dt / (d2 * sqrt(d2));

            a->v[0] -= d[0] * b->mass * mag;
            a->v[1] -= d[1] * b->mass * mag;
            a->v[2] -= d[2] * b->mass * mag;

            b->v[0] += d[0] * a->mass * mag;
            b->v[1] += d[1] * a->mass * mag;
            b->v[2] += d[2] * a->mass * mag;
         }
      }

      for (a = bodies, i = 0; i < N; i++, a++) {
         a->x[0] += dt * a->v[0];
         a->x[1] += dt * a->v[1];
         a->x[2] += dt * a->v[2];
      }
   }
}

double energy()
{
   //double e, d[3];
   double e, dx, dy, dz;
   int i, j, k;
   planet *a, *b;

   e = 0.0;
   for (i = 0, a = bodies; i < N; a++, i++) {
      e += a->mass * a->v[0] * a->v[0] / 2;
      e += a->mass * a->v[1] * a->v[1] / 2;
      e += a->mass * a->v[2] * a->v[2] / 2;

      for (j = i + 1, b = a + 1; j < N; b++, j++) {
         dx = a->x[0] - b->x[0];
         dy = a->x[1] - b->x[1];
         dz = a->x[2] - b->x[2];
         e -= (a->mass * b->mass) /
            sqrt(dx * dx + dy * dy + dz * dz);
      }
   }
   return e;
}

double solar_mass_;

void offset_momentum()
{
   int i, k;
   for (i = 0; i < N; i++)
      for_k { bodies[0].v[k] -= bodies[i].v[k] * bodies[i].mass / solar_mass_; }
}



int main(int argc, char **argv)
{
   int n = atoi(argv[1]);
   N = sizeof(bodies)/sizeof(planet);
   solar_mass_ = solar_mass;

   offset_momentum();
   printf("%.9f\n", energy());

   advance(0.01, n);

   printf("%.9f\n", energy());
   return 0;
}

nbody.go

/* The Computer Language Benchmarks Game
 * https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
 *
 * contributed by The Go Authors.
 * based on C program by Christoph Bauer
 * flag.Arg hack by Isaac Gouy
 * Modified by Antonio Petri
 */

package main

import (
	"flag"
	"fmt"
	"math"
	"strconv"
)

var n = 0

const (
	solarMass   = 4 * math.Pi * math.Pi
	daysPerYear = 365.24
	N           = 5
)

type Position struct{ x, y, z float64 }
type Momentum struct{ x, y, z, m float64 }
type System struct {
	v [N]Momentum
	s [N]Position
}

func offsetMomentum() {
	var px, py, pz float64
	for i := 0; i < N; i++ {
		px += sys.v[i].x * sys.v[i].m
		py += sys.v[i].y * sys.v[i].m
		pz += sys.v[i].z * sys.v[i].m
	}
	sys.v[0].x = -px / solarMass
	sys.v[0].y = -py / solarMass
	sys.v[0].z = -pz / solarMass
}

func energy() float64 {
	var e float64
	for i := 0; i < N; i++ {
		e += 0.5 * sys.v[i].m *
			(sys.v[i].x*sys.v[i].x + sys.v[i].y*sys.v[i].y + sys.v[i].z*sys.v[i].z)
		for j := i + 1; j < N; j++ {
			dx := sys.s[i].x - sys.s[j].x
			dy := sys.s[i].y - sys.s[j].y
			dz := sys.s[i].z - sys.s[j].z
			distance := math.Sqrt(dx*dx + dy*dy + dz*dz)
			e -= (sys.v[i].m * sys.v[j].m) / distance
		}
	}
	return e
}

func advance(dt float64, step int) {

	for step != 0 {
		step--
		for i := 0; i < N-1; i++ {
			_vx, _vy, _vz := sys.v[i].x, sys.v[i].y, sys.v[i].z

			for j := i + 1; j < N; j++ {

				dx := sys.s[i].x - sys.s[j].x
				dy := sys.s[i].y - sys.s[j].y
				dz := sys.s[i].z - sys.s[j].z

				dSquared := dx*dx + dy*dy + dz*dz
				distance := math.Sqrt(dSquared)
				mag := (dt / (dSquared * distance))
				mi := sys.v[i].m
				_vx -= dx * sys.v[j].m * mag
				_vy -= dy * sys.v[j].m * mag
				_vz -= dz * sys.v[j].m * mag
				sys.v[j].x += dx * mi * mag
				sys.v[j].y += dy * mi * mag
				sys.v[j].z += dz * mi * mag
			}
			sys.v[i].x, sys.v[i].y, sys.v[i].z = _vx, _vy, _vz
		}

		for i := 0; i < N; i++ {
			sys.s[i].x += dt * sys.v[i].x
			sys.s[i].y += dt * sys.v[i].y
			sys.s[i].z += dt * sys.v[i].z
		}
	}
}

var sys = System{
	v: [N]Momentum{
		{0.0, 0.0, 0.0, solarMass},
		{
			1.66007664274403694e-03 * daysPerYear,
			7.69901118419740425e-03 * daysPerYear,
			-6.90460016972063023e-05 * daysPerYear,
			9.54791938424326609e-04 * solarMass,
		},
		{
			-2.76742510726862411e-03 * daysPerYear,
			4.99852801234917238e-03 * daysPerYear,
			2.30417297573763929e-05 * daysPerYear,
			2.85885980666130812e-04 * solarMass,
		},
		{
			2.96460137564761618e-03 * daysPerYear,
			2.37847173959480950e-03 * daysPerYear,
			-2.96589568540237556e-05 * daysPerYear,
			4.36624404335156298e-05 * solarMass,
		},
		{
			2.68067772490389322e-03 * daysPerYear,
			1.62824170038242295e-03 * daysPerYear,
			-9.51592254519715870e-05 * daysPerYear,
			5.15138902046611451e-05 * solarMass,
		},
	},

	s: [N]Position{
		{0.0, 0.0, 0.0},
		{
			4.84143144246472090e+00,
			-1.16032004402742839e+00,
			-1.03622044471123109e-01,
		},
		{
			8.34336671824457987e+00,
			4.12479856412430479e+00,
			-4.03523417114321381e-01,
		},
		{
			1.28943695621391310e+01,
			-1.51111514016986312e+01,
			-2.23307578892655734e-01,
		},
		{
			1.53796971148509165e+01,
			-2.59193146099879641e+01,
			1.79258772950371181e-01,
		},
	},
}

func main() {
	flag.Parse()
	if flag.NArg() > 0 {
		n, _ = strconv.Atoi(flag.Arg(0))
	}
	offsetMomentum()

	fmt.Printf("%.9f\n", energy())
	advance(0.01, n)
	fmt.Printf("%.9f\n", energy())
}