Add portable interpreter benchmarks

Author: jfhamlin

benchmark/portable/README.md

@@ -0,0 +1,26 @@
+# Portable interpreter benchmarks
+
+These workloads exercise ordinary Clojure programs that run unchanged in both
+Glojure and let-go. They complement microbenchmarks by covering lazy sequences,
+persistent maps and vectors, higher-order collection operations, nested
+function calls, and integer-heavy loops.
+
+- `prime-workload.clj`: lazy prime generation and repeated factorization
+- `event-analytics.clj`: aggregation of 75,000 event maps
+- `game-of-life.clj`: 75 generations on a 48×48 board
+- `mandelbrot.clj`: fixed-point Mandelbrot calculation on a 120×72 grid
+
+Build Glojure, then compare it with a let-go executable:
+
+```sh
+go build -o /tmp/glj ./cmd/glj
+go run ./benchmark/portable \
+  -glojure /tmp/glj \
+  -let-go /path/to/lg \
+  -runs 11
+```
+
+The runner warms up both executables, checks that they produce identical
+output, alternates which executable runs first, and reports median wall-clock
+times. A Glojure/let-go ratio at or below `1.0` means Glojure is at least as
+fast for that workload.

benchmark/portable/compare.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"time"
+)
+
+var workloads = []string{
+	"prime-workload.clj",
+	"event-analytics.clj",
+	"game-of-life.clj",
+	"mandelbrot.clj",
+}
+
+func main() {
+	glojure := flag.String("glojure", "./bin/glj", "path to the Glojure executable")
+	letGo := flag.String("let-go", "lg", "path to the let-go executable")
+	runs := flag.Int("runs", 11, "timed runs per executable and workload")
+	dir := flag.String("dir", "benchmark/portable", "directory containing the workloads")
+	flag.Parse()
+
+	if *runs < 1 {
+		fmt.Fprintln(os.Stderr, "-runs must be at least 1")
+		os.Exit(2)
+	}
+
+	for _, workload := range workloads {
+		path := filepath.Join(*dir, workload)
+		glojureOutput, _, err := run(*glojure, path)
+		check(err, *glojure, path)
+		letGoOutput, _, err := run(*letGo, path)
+		check(err, *letGo, path)
+		if !bytes.Equal(glojureOutput, letGoOutput) {
+			fmt.Fprintf(os.Stderr, "%s produced different output\n", workload)
+			fmt.Fprintf(os.Stderr, "Glojure: %q\nlet-go:  %q\n", glojureOutput, letGoOutput)
+			os.Exit(1)
+		}
+
+		glojureTimes := make([]time.Duration, 0, *runs)
+		letGoTimes := make([]time.Duration, 0, *runs)
+		for iteration := 0; iteration < *runs; iteration++ {
+			if iteration%2 == 0 {
+				glojureTimes = append(glojureTimes, timedRun(*glojure, path))
+				letGoTimes = append(letGoTimes, timedRun(*letGo, path))
+			} else {
+				letGoTimes = append(letGoTimes, timedRun(*letGo, path))
+				glojureTimes = append(glojureTimes, timedRun(*glojure, path))
+			}
+		}
+
+		glojureMedian := median(glojureTimes)
+		letGoMedian := median(letGoTimes)
+		fmt.Printf(
+			"%-22s glojure=%-12s let-go=%-12s ratio=%.3f\n",
+			workload,
+			glojureMedian,
+			letGoMedian,
+			float64(glojureMedian)/float64(letGoMedian),
+		)
+	}
+}
+
+func timedRun(binary, workload string) time.Duration {
+	_, elapsed, err := run(binary, workload)
+	check(err, binary, workload)
+	return elapsed
+}
+
+func run(binary, workload string) ([]byte, time.Duration, error) {
+	start := time.Now()
+	output, err := exec.Command(binary, workload).CombinedOutput()
+	return output, time.Since(start), err
+}
+
+func check(err error, binary, workload string) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintf(os.Stderr, "%s failed while running %s: %v\n", binary, workload, err)
+	os.Exit(1)
+}
+
+func median(values []time.Duration) time.Duration {
+	sorted := slices.Clone(values)
+	slices.Sort(sorted)
+	middle := len(sorted) / 2
+	if len(sorted)%2 == 1 {
+		return sorted[middle]
+	}
+	return (sorted[middle-1] + sorted[middle]) / 2
+}

benchmark/portable/event-analytics.clj

@@ -0,0 +1,33 @@
+(def services [:api :worker :billing :search :notifications])
+(def statuses [200 200 200 201 204 400 404 429 500 503])
+(def event-count 75000)
+
+(defn event [i]
+  {:service (nth services (mod (+ (* i 7) 3) (count services)))
+   :status (nth statuses (mod (+ (* i 13) (quot i 17)) (count statuses)))
+   :latency-ms (+ 5 (mod (+ (* i 37) (quot i 11)) 900))
+   :bytes (+ 200 (mod (* i 7919) 50000))})
+
+(def summary
+  (reduce
+    (fn [totals e]
+      (let [service (:service e)
+            status (:status e)
+            failed (if (>= status 400) 1 0)]
+        (-> totals
+            (update-in [service :requests] (fnil inc 0))
+            (update-in [service :failures] (fnil + 0) failed)
+            (update-in [service :latency-ms] (fnil + 0) (:latency-ms e))
+            (update-in [service :bytes] (fnil + 0) (:bytes e)))))
+    {}
+    (map event (range event-count))))
+
+(println
+  (mapv
+    (fn [service]
+      [service
+       (get-in summary [service :requests])
+       (get-in summary [service :failures])
+       (get-in summary [service :latency-ms])
+       (get-in summary [service :bytes])])
+    services))

benchmark/portable/game-of-life.clj

@@ -0,0 +1,42 @@
+(def width 48)
+(def height 48)
+(def cell-count (* width height))
+
+(def initial
+  (mapv (fn [i]
+          (if (< (mod (+ (* i 17) (* i i 3)) 23) 7) 1 0))
+        (range cell-count)))
+
+(defn cell [state x y]
+  (nth state (+ (mod x width) (* width (mod y height)))))
+
+(defn neighbor-count [state i]
+  (let [x (mod i width)
+        y (quot i width)]
+    (+ (cell state (dec x) (dec y))
+       (cell state x       (dec y))
+       (cell state (inc x) (dec y))
+       (cell state (dec x) y)
+       (cell state (inc x) y)
+       (cell state (dec x) (inc y))
+       (cell state x       (inc y))
+       (cell state (inc x) (inc y)))))
+
+(defn step [state]
+  (mapv (fn [i]
+          (let [alive (nth state i)
+                n (neighbor-count state i)]
+            (if (or (= n 3) (and (= alive 1) (= n 2))) 1 0)))
+        (range cell-count)))
+
+(def final-state
+  (loop [state initial generation 0]
+    (if (= generation 75)
+      state
+      (recur (step state) (inc generation)))))
+
+(println
+  (loop [i 0 checksum 0]
+    (if (= i cell-count)
+      checksum
+      (recur (inc i) (+ checksum (* (inc i) (nth final-state i)))))))

benchmark/portable/mandelbrot.clj

@@ -0,0 +1,28 @@
+(def width 120)
+(def height 72)
+(def max-iterations 60)
+(def scale 1000)
+
+(defn escape-count [cx cy]
+  (loop [zr 0 zi 0 iteration 0]
+    (let [zr2 (quot (* zr zr) scale)
+          zi2 (quot (* zi zi) scale)]
+      (if (or (= iteration max-iterations)
+              (> (+ zr2 zi2) (* 4 scale)))
+        iteration
+        (recur (+ (- zr2 zi2) cx)
+               (+ (quot (* 2 zr zi) scale) cy)
+               (inc iteration))))))
+
+(println
+  (loop [y 0 checksum 0]
+    (if (= y height)
+      checksum
+      (let [cy (+ -1000 (quot (* y 2000) height))
+            row-sum
+            (loop [x 0 total 0]
+              (if (= x width)
+                total
+                (let [cx (+ -2500 (quot (* x 3500) width))]
+                  (recur (inc x) (+ total (escape-count cx cy))))))]
+        (recur (inc y) (+ checksum (* (inc y) row-sum)))))))

benchmark/portable/prime-workload.clj

@@ -0,0 +1,30 @@
+(defn prime? [n]
+  (cond
+    (< n 2) false
+    (= n 2) true
+    (even? n) false
+    :else
+    (loop [divisor 3]
+      (cond
+        (> (* divisor divisor) n) true
+        (zero? (mod n divisor)) false
+        :else (recur (+ divisor 2))))))
+
+(def primes (filter prime? (iterate inc 2)))
+
+(defn prime-factors [n]
+  (loop [remaining n candidates primes factors []]
+    (let [p (first candidates)]
+      (cond
+        (= remaining 1) factors
+        (zero? (mod remaining p))
+        (recur (quot remaining p) candidates (conj factors p))
+        (> (* p p) remaining) (conj factors remaining)
+        :else (recur remaining (next candidates) factors)))))
+
+(def inputs
+  (map (fn [i] (+ 1000003 (* i 210))) (range 500)))
+
+(println
+  [(reduce + 0 (take 2500 primes))
+   (reduce + 0 (mapcat prime-factors inputs))])