Benchmarks

This directory contains standalone CSP benchmarks implemented in Go, in C using libgoc, and in Clojure using core.async.

1. Channel ping-pong — Two tasks pass a single message back and forth, measuring the basic cost of a send/receive and the context switch it causes.
2. Ring — Many tasks are arranged in a circle and pass a token around, stressing scheduling and handoff overhead across a larger group.
3. Selective receive / fan-out / fan-in — One producer feeds many workers and a collector selects across multiple output channels, stressing select logic and load distribution.
4. Spawn idle tasks — Create many tasks that immediately block, highlighting creation time and memory overhead for lightweight tasks.
5. Prime sieve — A pipeline of filters passes numbers through channels to find primes, stressing long chains of tasks and sustained channel traffic.
6. HTTP ping-pong — Two HTTP/1.1 servers on loopback ports bounce a counter back and forth, measuring request/response overhead and integration between the HTTP layer and the task scheduler.
7. HTTP server throughput — One HTTP/1.1 server serves a tiny plaintext response while many concurrent keep-alive clients issue GET requests, measuring sustained requests/second under load.

Running

From this directory:

Combined runner

From this directory, you can run all benchmark suites (Go, Clojure, libgoc canary, and libgoc vmem) three times each with:

./run-all.sh

From the repository root, the equivalent command is:

./bench/run-all.sh

The script clears existing bench/logs/*.log files first, appends fresh output to the per-runtime log files, and stops immediately if any benchmark run fails.

Go

# Single run (uses default threads = nproc)
make -C go run

# Multi-pool testing (runs with GOMAXPROCS = 1, 2, 4, 8)
make -C go run all=1

libgoc

# Single run (uses default threads = nproc)
make -C libgoc run

# Multi-pool testing (runs with GOC_POOL_THREADS = 1, 2, 4, 8)
make -C libgoc run all=1

Clojure

Requires Clojure CLI tools.

# Single run (uses default threads = nproc)
make -C clojure run

# Multi-pool testing (runs with threads = 1, 2, 4, 8)
make -C clojure run all=1

Benchmark Status

Runs

Benchmark Environment

3 runs of each benchmark (Go, libgoc canary, libgoc vmem, Clojure) can be found in the bench/logs/ directory. The ./run-all.sh helper in this directory (or ./bench/run-all.sh from the repository root) regenerates those logs. All numbers in the report below are the best of those 3 runs for each pool size.

Report: libgoc vs. Go Baseline (+ Clojure)

This report evaluates the performance of libgoc canary, libgoc vmem, and Clojure core.async relative to the Go runtime. All figures represent operations per second; the multiplier in parentheses indicates performance relative to the Go baseline (e.g., 1.10x means 10% faster, 0.50x means half the speed).

Channel ping-pong (round trips/s)

Measures overhead of basic synchronization and context switching.

Ring (hops/s)

Measures message passing latency across a circular topology.

Selective receive / fan-out / fan-in (msg/s)

Evaluates complex orchestration and selection logic.

Spawn idle tasks (tasks/s)

Tests the efficiency of task creation and scheduling.

Prime sieve (primes/s)

High-concurrency filtering test.

HTTP ping-pong (round trips/s)

Two HTTP/1.1 servers on loopback bounce a counter back and forth.

HTTP server throughput (req/s)

One server, many concurrent keep-alive clients; measures sustained request rate.

Summary

Geometric mean of ×Go multipliers across pool sizes 1,2,4,8.

Takeaways:

• libgoc (canary) leads all HTTP benchmarks: ping-pong 1.67× Go geo mean, throughput 1.07× Go (from 0.37× previously) — major gains from the multi-loop + throughput work.
• Channel ping-pong/ring still strong at p1 (2.30×/2.32×), with some regression at higher pools vs earlier single-loop build (work-steal thrashing at p2+).
• Fan-out improved dramatically vs prior build: now 0.92× geo (from 0.57×) due to better multi-pool work distribution.
• Spawn idle remains libgoc's weakest point (0.14× canary) — expected given no goroutine-pool-style reuse.
• VMEM holds channel parity with canary at p1 (2.27×/2.33×) but shows larger HTTP throughput gap at higher pools (0.72× geo vs 1.07× canary) due to vmem GC overhead under concurrent I/O load.
• Clojure excels at spawn (1.88× geo) and HTTP throughput (1.35× geo, stable ~38k r/s regardless of pool) but trails everywhere else.
• Go unmatched at HTTP-thru scaling (77k r/s p8).
• Overall: libgoc canary 0.91× Go geo-mean across 28 metrics — strong C CSP runtime, HTTP now competitive.

For root-cause analysis, fixes, and optimization roadmap, see OPTIMIZATION.md.