odin

Author: hanabi1224

.github/odin.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/sh
+
+VERSION=dev-2022-04
+FILE_NAME=odin-ubuntu_amd64-$VERSION.zip
+
+mkdir /tmp/odin
+cd /tmp/odin
+wget https://github.com/odin-lang/Odin/releases/download/$VERSION/$FILE_NAME
+unzip -o $FILE_NAME
+sudo chmod +x odin
+sudo ln -sf $PWD/odin /usr/bin/odin
+odin version

.github/workflows/bench.yml

@@ -38,6 +38,7 @@ jobs:
             lua,
             nim,
             ocaml,
+            odin,
             perl,
             php,
             pony,
@@ -130,6 +131,9 @@ jobs:
       - name: Install hhvm
         if: matrix.lang == 'hack'
         run: ./.github/hhvm.sh
+      - name: Install odin
+        if: matrix.lang == 'odin'
+        run: ./.github/odin.sh
       - uses: dlang-community/setup-dlang@v1
         if: matrix.lang == 'd'
         with:

bench/algorithm/helloworld/1.odin

@@ -0,0 +1,10 @@
+package main
+
+import "core:fmt"
+import "core:runtime"
+
+main :: proc() {
+    args := runtime.args__
+    name := len(args) > 1 ? args[1] : ""
+	fmt.printf("Hello world %s!\n", name)
+}

bench/algorithm/lru/1.odin

@@ -0,0 +1,47 @@
+package main
+
+import "core:container/lru"
+import "core:fmt"
+import "core:runtime"
+import "core:strconv"
+
+A : uint : 1103515245
+C : uint : 12345
+M : uint : 1 << 31
+LCG :: struct { seed: uint }
+next_lcg :: proc(lcg : ^LCG) -> uint {
+    seed := (A * lcg.seed + C) % M
+    lcg.seed = seed
+    return seed
+}
+
+main :: proc() {
+    args := runtime.args__
+    size := strconv.parse_uint(auto_cast args[1]) or_else 100
+    n := strconv.parse_int(auto_cast args[2]) or_else 100
+    mod := size * 10
+    rng0 := &LCG { 0 }
+    rng1 := &LCG { 1 }
+    cache := new(lru.Cache(uint, uint))
+    defer free(cache)
+    lru.init(cache, auto_cast size)
+    hit := 0
+    missed := 0
+    for _ in 0..<n {
+        n0 := next_lcg(rng0) % mod
+        lru.set(cache, n0, n0)
+        n1 := next_lcg(rng1) % mod
+        if _, ok := lru.get(cache, n1); ok {
+            hit += 1
+            // BUG: below lines should not be needed if lru lib works properly
+            lru.remove(cache, n1)
+            lru.set(cache, n1, n1)
+        } 
+        else {
+            missed += 1
+        }
+        // fmt.printf("hit: %d, missed: %d, n0: %d, n1: %d\n", hit, missed, n0, n1)
+    }
+    fmt.println(hit)
+    fmt.println(missed)
+}

bench/algorithm/nbody/1.odin

@@ -0,0 +1,98 @@
+package main
+
+import "core:fmt"
+import "core:math"
+import "core:runtime"
+import "core:strconv"
+
+PI :: 3.141592653589793
+SOLAR_MASS :: 4 * PI * PI
+DAYS_PER_YEAR :: 365.24
+
+Vec3 :: [3]f64
+Body :: struct { pos: Vec3, velocity: Vec3, mass: f64 }
+Sys :: [5]Body
+
+init_body :: proc(x, y, z, vx, vy, vz, mass : f64) -> Body {
+    return Body { [3]f64 {x, y, z}, [3]f64 {vx, vy, vz}*DAYS_PER_YEAR, mass*SOLAR_MASS }
+}
+
+init_sys :: proc() -> Sys {
+    return Sys {
+        // Sun
+        init_body(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
+        // Jupiter
+        init_body(4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01, 
+            1.66007664274403694e-03, 7.69901118419740425e-03, -6.90460016972063023e-05,
+            9.54791938424326609e-04),
+        // Saturn
+        init_body(8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
+            -2.76742510726862411e-03, 4.99852801234917238e-03, 2.30417297573763929e-05,
+            2.85885980666130812e-04),
+        // Uranus
+        init_body(1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
+            2.96460137564761618e-03, 2.37847173959480950e-03, -2.96589568540237556e-05,
+            4.36624404335156298e-05),
+        // Neptune
+        init_body(1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
+            2.68067772490389322e-03, 1.62824170038242295e-03, -9.51592254519715870e-05,
+            5.15138902046611451e-05),
+    }
+}
+
+advance :: proc(sys: ^Sys, dt: f64) {
+    for b, i in sys {
+        v := b.velocity
+        for j in (i+1)..<5 {
+            b2 := &sys[j]
+            dpos := b.pos - b2.pos
+            distance_square := sum(dpos * dpos)
+            distance := math.sqrt_f64(distance_square)
+            mag := dt / (distance * distance_square)
+            v -= dpos * (mag * b2.mass)
+            b2.velocity += dpos * (mag * b.mass)
+        }
+        b.velocity = v
+        b.pos += v * dt
+    }
+}
+
+offset_momentum :: proc(sys: ^Sys) {
+    p := Vec3 {}
+    for b, _ in sys {
+        p -= b.velocity * b.mass
+    }
+    sys[0].velocity = p / SOLAR_MASS
+}
+
+sum :: proc (v: Vec3) -> f64 {
+    return v[0] + v[1] + v[2]
+}
+
+energy :: proc(sys: ^Sys) -> f64 {
+    e := 0.0
+    for b, i in sys {
+        e += 0.5 * b.mass * sum(b.velocity * b.velocity)
+        for j in (i+1)..<5 {
+            b2 := sys[j]
+            dpos := b.pos - b2.pos
+            distance_square := sum(dpos * dpos)
+            distance := math.sqrt_f64(distance_square)
+            e -= b.mass * b2.mass / distance
+        }
+    }
+    return e
+}
+
+main :: proc() {
+    args := runtime.args__
+    n := strconv.parse_int(auto_cast args[1]) or_else 1000
+    
+    sys := init_sys()
+    offset_momentum(&sys)
+    fmt.printf("%.9f\n", energy(&sys))
+    for _ in 0..<n {
+        advance(&sys, 0.01)
+    }
+    fmt.printf("%.9f\n", energy(&sys))
+}

bench/algorithm/nsieve/1.odin

@@ -0,0 +1,29 @@
+package main
+
+import "core:fmt"
+import "core:runtime"
+import "core:strconv"
+
+main :: proc() {
+    args := runtime.args__
+    n := strconv.parse_int(runtime.cstring_to_string(args[1])) or_else 4
+    for i in 0..<3 {
+        shift : uint = auto_cast (n - i)
+        nsieve(10000 << shift)
+    }
+}
+
+nsieve :: proc(n : int) {
+    flags := make([]bool, n)
+    defer delete(flags)
+    count := 0
+    for i in 2..<n {
+        if !flags[i] {
+            count += 1
+            for j := i << 1; j < n; j += i {
+                flags[j] = true
+            }
+        }
+    }
+    fmt.printf("Primes up to %8s %8s\n", fmt.tprint(n), fmt.tprint(count))
+}

bench/algorithm/nsieve/2.odin

@@ -0,0 +1,30 @@
+package main
+
+import "core:container/bit_array"
+import "core:fmt"
+import "core:runtime"
+import "core:strconv"
+
+main :: proc() {
+    args := runtime.args__
+    n := strconv.parse_int(runtime.cstring_to_string(args[1])) or_else 4
+    for i in 0..<3 {
+        shift : uint = auto_cast (n - i)
+        nsieve(10000 << shift)
+    }
+}
+
+nsieve :: proc(n : int) {
+    flags, _ := bit_array.create(n)
+    defer bit_array.destroy(flags)
+    count := 0
+    for i in 2..<n {
+        if res, _ := bit_array.get(flags, i); !res {
+            count += 1
+            for j := i << 1; j < n; j += i {
+                bit_array.set(flags, j)
+            }
+        }
+    }
+    fmt.printf("Primes up to %8s %8s\n", fmt.tprint(n), fmt.tprint(count))
+}

bench/algorithm/nsieve/5_out

@@ -0,0 +1,3 @@
+Primes up to   320000    27608
+Primes up to   160000    14683
+Primes up to    80000     7837

bench/bench.yaml

@@ -13,6 +13,8 @@ problems:
     unittests:
       - input: 4
         output: 4_out
+      - input: 5
+        output: 5_out
     tests:
       - input: 10
       - input: 12

bench/bench_odin.yaml

@@ -0,0 +1,29 @@
+lang: odin
+problems:
+  - name: helloworld
+    source:
+      - 1.odin
+  - name: nsieve
+    source:
+      - 1.odin
+      - 2.odin
+  - name: lru
+    source:
+      # BUG: core:container/lru
+      # - 1.odin
+  - name: nbody
+    source:
+      - 1.odin
+compiler_version_command: odin version
+runtime_version_parameter:
+source_rename_to: app.odin
+environments:
+  - os: linux
+    compiler: odin
+    version: latest
+    docker:
+    include:
+    build: odin build . -out:out/app -o:speed -disable-assert -no-bounds-check -vet -microarch:broadwell -show-timings
+    out_dir: out
+    run_cmd: app
+    allow_failure: true