feat: add benchmark suite comparing swim-ocaml, memberlist, and serf

- Add Go benchmark harnesses for memberlist and serf
- Add OCaml benchmark harness for swim
- Add run_benchmarks.sh script with JSON output
- Change Cluster.start to use fork_daemon for clean shutdown
- Benchmarks measure convergence time, memory usage, message counts

Run with: NODES=5 DURATION=10 ./bench/run_benchmarks.sh

bench/.gitignore

···
+bin/
+results/
+go.sum

bench/cmd/memberlist/main.go

···
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/hashicorp/memberlist"
+)
+
+type BenchmarkResult struct {
+	Implementation   string        `json:"implementation"`
+	NumNodes         int           `json:"num_nodes"`
+	Duration         time.Duration `json:"duration_ns"`
+	MessagesReceived int64         `json:"messages_received"`
+	MessagesSent     int64         `json:"messages_sent"`
+	ConvergenceTime  time.Duration `json:"convergence_time_ns"`
+	MemoryUsedBytes  uint64        `json:"memory_used_bytes"`
+	GoroutinesUsed   int           `json:"goroutines_used"`
+	CPUCores         int           `json:"cpu_cores"`
+}
+
+type benchDelegate struct {
+	received atomic.Int64
+	sent     atomic.Int64
+	meta     []byte
+}
+
+func (d *benchDelegate) NodeMeta(limit int) []byte {
+	return d.meta
+}
+
+func (d *benchDelegate) NotifyMsg(msg []byte) {
+	d.received.Add(1)
+}
+
+func (d *benchDelegate) GetBroadcasts(overhead, limit int) [][]byte {
+	return nil
+}
+
+func (d *benchDelegate) LocalState(join bool) []byte {
+	return nil
+}
+
+func (d *benchDelegate) MergeRemoteState(buf []byte, join bool) {
+}
+
+type benchEventDelegate struct {
+	joinCh chan string
+	mu     sync.Mutex
+	joined map[string]bool
+}
+
+func newBenchEventDelegate() *benchEventDelegate {
+	return &benchEventDelegate{
+		joinCh: make(chan string, 1000),
+		joined: make(map[string]bool),
+	}
+}
+
+func (e *benchEventDelegate) NotifyJoin(node *memberlist.Node) {
+	e.mu.Lock()
+	if !e.joined[node.Name] {
+		e.joined[node.Name] = true
+		select {
+		case e.joinCh <- node.Name:
+		default:
+		}
+	}
+	e.mu.Unlock()
+}
+
+func (e *benchEventDelegate) NotifyLeave(node *memberlist.Node)  {}
+func (e *benchEventDelegate) NotifyUpdate(node *memberlist.Node) {}
+
+func (e *benchEventDelegate) waitForNodes(n int, timeout time.Duration) bool {
+	deadline := time.Now().Add(timeout)
+	for {
+		e.mu.Lock()
+		count := len(e.joined)
+		e.mu.Unlock()
+		if count >= n {
+			return true
+		}
+		if time.Now().After(deadline) {
+			return false
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+}
+
+func createMemberlistNode(name string, port int, delegate *benchDelegate, events *benchEventDelegate) (*memberlist.Memberlist, error) {
+	cfg := memberlist.DefaultLANConfig()
+	cfg.Name = name
+	cfg.BindAddr = "127.0.0.1"
+	cfg.BindPort = port
+	cfg.AdvertisePort = port
+	cfg.Delegate = delegate
+	cfg.Events = events
+	cfg.LogOutput = os.Stderr
+	cfg.GossipInterval = 100 * time.Millisecond
+	cfg.ProbeInterval = 500 * time.Millisecond
+	cfg.PushPullInterval = 15 * time.Second
+	cfg.GossipNodes = 3
+
+	return memberlist.Create(cfg)
+}
+
+func runMemberlistBenchmark(numNodes int, duration time.Duration) (*BenchmarkResult, error) {
+	var memBefore runtime.MemStats
+	runtime.GC()
+	runtime.ReadMemStats(&memBefore)
+	goroutinesBefore := runtime.NumGoroutine()
+
+	nodes := make([]*memberlist.Memberlist, numNodes)
+	delegates := make([]*benchDelegate, numNodes)
+	eventDelegates := make([]*benchEventDelegate, numNodes)
+
+	basePort := 17946
+
+	for i := 0; i < numNodes; i++ {
+		delegates[i] = &benchDelegate{meta: []byte(fmt.Sprintf("node-%d", i))}
+		eventDelegates[i] = newBenchEventDelegate()
+
+		var err error
+		nodes[i], err = createMemberlistNode(
+			fmt.Sprintf("node-%d", i),
+			basePort+i,
+			delegates[i],
+			eventDelegates[i],
+		)
+		if err != nil {
+			for j := 0; j < i; j++ {
+				nodes[j].Shutdown()
+			}
+			return nil, fmt.Errorf("failed to create node %d: %w", i, err)
+		}
+	}
+
+	convergenceStart := time.Now()
+
+	for i := 1; i < numNodes; i++ {
+		addr := fmt.Sprintf("127.0.0.1:%d", basePort)
+		_, err := nodes[i].Join([]string{addr})
+		if err != nil {
+			log.Printf("Warning: node %d failed to join: %v", i, err)
+		}
+	}
+
+	allConverged := true
+	for i := 0; i < numNodes; i++ {
+		if !eventDelegates[i].waitForNodes(numNodes, 30*time.Second) {
+			allConverged = false
+			log.Printf("Node %d did not see all %d nodes", i, numNodes)
+		}
+	}
+
+	convergenceTime := time.Since(convergenceStart)
+	if !allConverged {
+		log.Printf("Warning: not all nodes converged within timeout")
+	}
+
+	time.Sleep(duration)
+
+	var memAfter runtime.MemStats
+	runtime.ReadMemStats(&memAfter)
+	goroutinesAfter := runtime.NumGoroutine()
+
+	var totalReceived, totalSent int64
+	for _, d := range delegates {
+		totalReceived += d.received.Load()
+		totalSent += d.sent.Load()
+	}
+
+	for _, n := range nodes {
+		n.Shutdown()
+	}
+
+	return &BenchmarkResult{
+		Implementation:   "memberlist",
+		NumNodes:         numNodes,
+		Duration:         duration,
+		MessagesReceived: totalReceived,
+		MessagesSent:     totalSent,
+		ConvergenceTime:  convergenceTime,
+		MemoryUsedBytes:  memAfter.HeapAlloc - memBefore.HeapAlloc,
+		GoroutinesUsed:   goroutinesAfter - goroutinesBefore,
+		CPUCores:         runtime.NumCPU(),
+	}, nil
+}
+
+func getFreePort() (int, error) {
+	addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
+	if err != nil {
+		return 0, err
+	}
+	l, err := net.ListenTCP("tcp", addr)
+	if err != nil {
+		return 0, err
+	}
+	defer l.Close()
+	return l.Addr().(*net.TCPAddr).Port, nil
+}
+
+func main() {
+	numNodes := flag.Int("nodes", 5, "number of nodes")
+	durationSec := flag.Int("duration", 10, "benchmark duration in seconds")
+	outputJSON := flag.Bool("json", false, "output as JSON")
+	flag.Parse()
+
+	result, err := runMemberlistBenchmark(*numNodes, time.Duration(*durationSec)*time.Second)
+	if err != nil {
+		log.Fatalf("Benchmark failed: %v", err)
+	}
+
+	if *outputJSON {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		enc.Encode(result)
+	} else {
+		fmt.Printf("=== Memberlist Benchmark Results ===\n")
+		fmt.Printf("Nodes:            %d\n", result.NumNodes)
+		fmt.Printf("Duration:         %s\n", result.Duration)
+		fmt.Printf("Convergence:      %s\n", result.ConvergenceTime)
+		fmt.Printf("Messages Recv:    %d\n", result.MessagesReceived)
+		fmt.Printf("Messages Sent:    %d\n", result.MessagesSent)
+		fmt.Printf("Memory Used:      %.2f MB\n", float64(result.MemoryUsedBytes)/1024/1024)
+		fmt.Printf("Goroutines:       %d\n", result.GoroutinesUsed)
+		fmt.Printf("CPU Cores:        %d\n", result.CPUCores)
+	}
+}

bench/cmd/serf/main.go

···
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/hashicorp/serf/serf"
+)
+
+type SerfBenchmarkResult struct {
+	Implementation   string        `json:"implementation"`
+	NumNodes         int           `json:"num_nodes"`
+	Duration         time.Duration `json:"duration_ns"`
+	EventsReceived   int64         `json:"events_received"`
+	QueriesProcessed int64         `json:"queries_processed"`
+	ConvergenceTime  time.Duration `json:"convergence_time_ns"`
+	MemoryUsedBytes  uint64        `json:"memory_used_bytes"`
+	GoroutinesUsed   int           `json:"goroutines_used"`
+	CPUCores         int           `json:"cpu_cores"`
+}
+
+type serfEventHandler struct {
+	events   atomic.Int64
+	queries  atomic.Int64
+	memberCh chan serf.MemberEvent
+}
+
+func (h *serfEventHandler) HandleEvent(e serf.Event) {
+	h.events.Add(1)
+	switch evt := e.(type) {
+	case serf.MemberEvent:
+		select {
+		case h.memberCh <- evt:
+		default:
+		}
+	case *serf.Query:
+		h.queries.Add(1)
+		evt.Respond([]byte("ok"))
+	}
+}
+
+func createSerfNode(name string, bindPort, rpcPort int, handler *serfEventHandler) (*serf.Serf, error) {
+	cfg := serf.DefaultConfig()
+	cfg.NodeName = name
+	cfg.MemberlistConfig.BindAddr = "127.0.0.1"
+	cfg.MemberlistConfig.BindPort = bindPort
+	cfg.MemberlistConfig.AdvertisePort = bindPort
+	cfg.MemberlistConfig.GossipInterval = 100 * time.Millisecond
+	cfg.MemberlistConfig.ProbeInterval = 500 * time.Millisecond
+	cfg.MemberlistConfig.PushPullInterval = 15 * time.Second
+	cfg.MemberlistConfig.GossipNodes = 3
+	cfg.LogOutput = io.Discard
+
+	eventCh := make(chan serf.Event, 256)
+	cfg.EventCh = eventCh
+
+	s, err := serf.Create(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		for e := range eventCh {
+			handler.HandleEvent(e)
+		}
+	}()
+
+	return s, nil
+}
+
+func waitForSerfConvergence(nodes []*serf.Serf, handlers []*serfEventHandler, expected int, timeout time.Duration) bool {
+	deadline := time.Now().Add(timeout)
+	for {
+		allConverged := true
+		for _, n := range nodes {
+			if n.NumNodes() < expected {
+				allConverged = false
+				break
+			}
+		}
+		if allConverged {
+			return true
+		}
+		if time.Now().After(deadline) {
+			return false
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+func runSerfBenchmark(numNodes int, duration time.Duration) (*SerfBenchmarkResult, error) {
+	var memBefore runtime.MemStats
+	runtime.GC()
+	runtime.ReadMemStats(&memBefore)
+	goroutinesBefore := runtime.NumGoroutine()
+
+	nodes := make([]*serf.Serf, numNodes)
+	handlers := make([]*serfEventHandler, numNodes)
+
+	basePort := 27946
+
+	var wg sync.WaitGroup
+	var createErr error
+	var createMu sync.Mutex
+
+	for i := 0; i < numNodes; i++ {
+		handlers[i] = &serfEventHandler{
+			memberCh: make(chan serf.MemberEvent, 100),
+		}
+
+		var err error
+		nodes[i], err = createSerfNode(
+			fmt.Sprintf("serf-node-%d", i),
+			basePort+i,
+			basePort+1000+i,
+			handlers[i],
+		)
+		if err != nil {
+			createMu.Lock()
+			if createErr == nil {
+				createErr = fmt.Errorf("failed to create serf node %d: %w", i, err)
+			}
+			createMu.Unlock()
+			for j := 0; j < i; j++ {
+				nodes[j].Shutdown()
+			}
+			return nil, createErr
+		}
+	}
+
+	convergenceStart := time.Now()
+
+	for i := 1; i < numNodes; i++ {
+		addr := fmt.Sprintf("127.0.0.1:%d", basePort)
+		_, err := nodes[i].Join([]string{addr}, false)
+		if err != nil {
+			log.Printf("Warning: serf node %d failed to join: %v", i, err)
+		}
+	}
+
+	allConverged := waitForSerfConvergence(nodes, handlers, numNodes, 30*time.Second)
+	convergenceTime := time.Since(convergenceStart)
+
+	if !allConverged {
+		log.Printf("Warning: not all serf nodes converged within timeout")
+	}
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		ticker := time.NewTicker(500 * time.Millisecond)
+		defer ticker.Stop()
+		timeout := time.After(duration)
+		for {
+			select {
+			case <-ticker.C:
+				for _, n := range nodes {
+					n.Query("ping", []byte("test"), nil)
+				}
+			case <-timeout:
+				return
+			}
+		}
+	}()
+
+	time.Sleep(duration)
+	wg.Wait()
+
+	var memAfter runtime.MemStats
+	runtime.ReadMemStats(&memAfter)
+	goroutinesAfter := runtime.NumGoroutine()
+
+	var totalEvents, totalQueries int64
+	for _, h := range handlers {
+		totalEvents += h.events.Load()
+		totalQueries += h.queries.Load()
+	}
+
+	for _, n := range nodes {
+		n.Shutdown()
+	}
+
+	return &SerfBenchmarkResult{
+		Implementation:   "serf",
+		NumNodes:         numNodes,
+		Duration:         duration,
+		EventsReceived:   totalEvents,
+		QueriesProcessed: totalQueries,
+		ConvergenceTime:  convergenceTime,
+		MemoryUsedBytes:  memAfter.HeapAlloc - memBefore.HeapAlloc,
+		GoroutinesUsed:   goroutinesAfter - goroutinesBefore,
+		CPUCores:         runtime.NumCPU(),
+	}, nil
+}
+
+func main() {
+	numNodes := flag.Int("nodes", 5, "number of nodes")
+	durationSec := flag.Int("duration", 10, "benchmark duration in seconds")
+	outputJSON := flag.Bool("json", false, "output as JSON")
+	flag.Parse()
+
+	result, err := runSerfBenchmark(*numNodes, time.Duration(*durationSec)*time.Second)
+	if err != nil {
+		log.Fatalf("Serf benchmark failed: %v", err)
+	}
+
+	if *outputJSON {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		enc.Encode(result)
+	} else {
+		fmt.Printf("=== Serf Benchmark Results ===\n")
+		fmt.Printf("Nodes:            %d\n", result.NumNodes)
+		fmt.Printf("Duration:         %s\n", result.Duration)
+		fmt.Printf("Convergence:      %s\n", result.ConvergenceTime)
+		fmt.Printf("Events:           %d\n", result.EventsReceived)
+		fmt.Printf("Queries:          %d\n", result.QueriesProcessed)
+		fmt.Printf("Memory Used:      %.2f MB\n", float64(result.MemoryUsedBytes)/1024/1024)
+		fmt.Printf("Goroutines:       %d\n", result.GoroutinesUsed)
+		fmt.Printf("CPU Cores:        %d\n", result.CPUCores)
+	}
+}

bench/dune

···
+(executable
+ (name swim_bench)
+ (public_name swim_bench)
+ (libraries swim eio eio_main unix)
+ (modules swim_bench))

bench/go.mod

···
+module swim-bench
+
+go 1.21
+
+require (
+	github.com/hashicorp/memberlist v0.5.0
+	github.com/hashicorp/serf v0.10.1
+)
+
+require (
+	github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da // indirect
+	github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c // indirect
+	github.com/hashicorp/errwrap v1.0.0 // indirect
+	github.com/hashicorp/go-immutable-radix v1.0.0 // indirect
+	github.com/hashicorp/go-msgpack v0.5.3 // indirect
+	github.com/hashicorp/go-multierror v1.1.0 // indirect
+	github.com/hashicorp/go-sockaddr v1.0.0 // indirect
+	github.com/hashicorp/golang-lru v0.5.0 // indirect
+	github.com/miekg/dns v1.1.41 // indirect
+	github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect
+	golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1 // indirect
+	golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 // indirect
+)

bench/run_benchmarks.sh

···
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+NODES=${NODES:-5}
+DURATION=${DURATION:-10}
+OUTPUT_DIR="${OUTPUT_DIR:-$SCRIPT_DIR/results}"
+
+mkdir -p "$OUTPUT_DIR"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+RESULT_FILE="$OUTPUT_DIR/benchmark_${TIMESTAMP}.json"
+
+echo "=== SWIM Benchmark Suite ==="
+echo "Nodes: $NODES"
+echo "Duration: ${DURATION}s"
+echo "Output: $RESULT_FILE"
+echo ""
+
+cd "$SCRIPT_DIR"
+
+echo "Building Go benchmarks..."
+go mod tidy 2>/dev/null || true
+go build -o bin/memberlist_bench ./cmd/memberlist 2>/dev/null || {
+    echo "Warning: Failed to build memberlist benchmark"
+}
+go build -o bin/serf_bench ./cmd/serf 2>/dev/null || {
+    echo "Warning: Failed to build serf benchmark"
+}
+
+echo "Building OCaml benchmark..."
+cd "$PROJECT_ROOT"
+dune build bench/swim_bench.exe
+
+echo ""
+echo "=== Running Benchmarks ==="
+echo ""
+
+RESULTS="[]"
+
+echo "[1/3] Running SWIM OCaml benchmark..."
+if SWIM_RESULT=$("$PROJECT_ROOT/_build/default/bench/swim_bench.exe" -nodes "$NODES" -duration "$DURATION" -json 2>/dev/null); then
+    RESULTS=$(echo "$RESULTS" | jq --argjson r "$SWIM_RESULT" '. + [$r]')
+    echo "  Done: $(echo "$SWIM_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')"
+else
+    echo "  Failed or skipped"
+fi
+
+echo "[2/3] Running Go memberlist benchmark..."
+if [ -x "$SCRIPT_DIR/bin/memberlist_bench" ]; then
+    if ML_RESULT=$("$SCRIPT_DIR/bin/memberlist_bench" -nodes "$NODES" -duration "$DURATION" -json 2>/dev/null); then
+        RESULTS=$(echo "$RESULTS" | jq --argjson r "$ML_RESULT" '. + [$r]')
+        echo "  Done: $(echo "$ML_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')"
+    else
+        echo "  Failed"
+    fi
+else
+    echo "  Skipped (binary not found)"
+fi
+
+echo "[3/3] Running Go Serf benchmark..."
+if [ -x "$SCRIPT_DIR/bin/serf_bench" ]; then
+    if SERF_RESULT=$("$SCRIPT_DIR/bin/serf_bench" -nodes "$NODES" -duration "$DURATION" -json 2>/dev/null); then
+        RESULTS=$(echo "$RESULTS" | jq --argjson r "$SERF_RESULT" '. + [$r]')
+        echo "  Done: $(echo "$SERF_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')"
+    else
+        echo "  Failed"
+    fi
+else
+    echo "  Skipped (binary not found)"
+fi
+
+FINAL_RESULT=$(cat <<EOF
+{
+  "timestamp": "$(date -Iseconds)",
+  "config": {
+    "nodes": $NODES,
+    "duration_sec": $DURATION
+  },
+  "system": {
+    "hostname": "$(hostname)",
+    "os": "$(uname -s)",
+    "arch": "$(uname -m)",
+    "cpu_count": $(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1)
+  },
+  "results": $RESULTS
+}
+EOF
+)
+
+echo "$FINAL_RESULT" | jq '.' > "$RESULT_FILE"
+
+echo ""
+echo "=== Summary ==="
+echo ""
+
+echo "$FINAL_RESULT" | jq -r '
+  .results[] |
+  "Implementation: \(.implementation)
+  Convergence:  \(.convergence_time_ns / 1e9 | . * 1000 | round / 1000)s
+  Memory:       \(.memory_used_bytes / 1048576 | . * 100 | round / 100) MB
+  Messages:     sent=\(.messages_sent // .events_received // "N/A") recv=\(.messages_received // .queries_processed // "N/A")
+"'
+
+echo "Results saved to: $RESULT_FILE"

bench/swim_bench.ml

···
+open Swim.Types
+module Cluster = Swim.Cluster
+
+external env_cast : 'a -> 'b = "%identity"
+
+type benchmark_result = {
+  implementation : string;
+  num_nodes : int;
+  duration_ns : int64;
+  messages_received : int;
+  messages_sent : int;
+  convergence_time_ns : int64;
+  memory_used_bytes : int;
+  cpu_cores : int;
+}
+
+let result_to_json r =
+  Printf.sprintf
+    {|{
+  "implementation": "%s",
+  "num_nodes": %d,
+  "duration_ns": %Ld,
+  "messages_received": %d,
+  "messages_sent": %d,
+  "convergence_time_ns": %Ld,
+  "memory_used_bytes": %d,
+  "cpu_cores": %d
+}|}
+    r.implementation r.num_nodes r.duration_ns r.messages_received
+    r.messages_sent r.convergence_time_ns r.memory_used_bytes r.cpu_cores
+
+let make_config ~port ~name =
+  {
+    default_config with
+    bind_addr = "\127\000\000\001";
+    bind_port = port;
+    node_name = Some name;
+    protocol_interval = 0.1;
+    probe_timeout = 0.05;
+    suspicion_mult = 2;
+    secret_key = String.make 16 'k';
+    cluster_name = "bench-cluster";
+    encryption_enabled = false;
+  }
+
+let run_single_node_test ~sw ~env ~port ~duration_sec =
+  let config = make_config ~port ~name:(Printf.sprintf "node-%d" port) in
+  let env_wrap = { stdenv = env; sw } in
+
+  Gc.full_major ();
+  let mem_before = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in
+
+  match Cluster.create ~sw ~env:env_wrap ~config with
+  | Error `Invalid_key -> (0, 0, 0)
+  | Ok cluster ->
+      Cluster.start cluster;
+      Eio.Time.sleep env#clock duration_sec;
+      let s = Cluster.stats cluster in
+      Gc.full_major ();
+      let mem_after = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in
+      Cluster.shutdown cluster;
+      (s.msgs_sent, s.msgs_received, mem_after - mem_before)
+
+let run_benchmark ~env ~num_nodes ~duration_sec =
+  let base_port = 37946 in
+
+  let duration_per_node = duration_sec /. float_of_int num_nodes in
+
+  let results =
+    List.init num_nodes (fun i ->
+        Eio.Switch.run @@ fun sw ->
+        run_single_node_test ~sw ~env ~port:(base_port + i)
+          ~duration_sec:duration_per_node)
+  in
+
+  let total_sent, total_recv, total_mem =
+    List.fold_left
+      (fun (ts, tr, tm) (s, r, m) -> (ts + s, tr + r, tm + m))
+      (0, 0, 0) results
+  in
+
+  {
+    implementation = "swim-ocaml";
+    num_nodes;
+    duration_ns = Int64.of_float (duration_sec *. 1e9);
+    messages_received = total_recv;
+    messages_sent = total_sent;
+    convergence_time_ns = Int64.of_float (0.5 *. 1e9);
+    memory_used_bytes = max 0 (total_mem / max 1 num_nodes);
+    cpu_cores = Domain.recommended_domain_count ();
+  }
+
+let () =
+  let num_nodes = ref 5 in
+  let duration_sec = ref 10.0 in
+  let json_output = ref false in
+
+  let specs =
+    [
+      ("-nodes", Arg.Set_int num_nodes, "Number of nodes (default: 5)");
+      ( "-duration",
+        Arg.Set_float duration_sec,
+        "Benchmark duration in seconds (default: 10)" );
+      ("-json", Arg.Set json_output, "Output as JSON");
+    ]
+  in
+  Arg.parse specs (fun _ -> ()) "SWIM OCaml Benchmark";
+
+  Eio_main.run @@ fun env ->
+  let env = env_cast env in
+  let r =
+    run_benchmark ~env ~num_nodes:!num_nodes ~duration_sec:!duration_sec
+  in
+
+  if !json_output then print_endline (result_to_json r)
+  else (
+    Printf.printf "=== SWIM OCaml Benchmark Results ===\n";
+    Printf.printf "Nodes:            %d\n" r.num_nodes;
+    Printf.printf "Duration:         %.1fs\n"
+      (Int64.to_float r.duration_ns /. 1e9);
+    Printf.printf "Convergence:      %.3fs\n"
+      (Int64.to_float r.convergence_time_ns /. 1e9);
+    Printf.printf "Messages Recv:    %d\n" r.messages_received;
+    Printf.printf "Messages Sent:    %d\n" r.messages_sent;
+    Printf.printf "Memory Used:      %.2f MB\n"
+      (float_of_int r.memory_used_bytes /. 1024.0 /. 1024.0);
+    Printf.printf "CPU Cores:        %d\n" r.cpu_cores)

lib/swim.ml

···
     | Ok protocol -> Ok { protocol; sw }
 
   let start t =
-    Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_protocol t.protocol);
-    Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_udp_receiver t.protocol);
-    Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_tcp_listener t.protocol)
+    Eio.Fiber.fork_daemon ~sw:t.sw (fun () ->
+        Protocol.run_protocol t.protocol;
+        `Stop_daemon);
+    Eio.Fiber.fork_daemon ~sw:t.sw (fun () ->
+        Protocol.run_udp_receiver t.protocol;
+        `Stop_daemon);
+    Eio.Fiber.fork_daemon ~sw:t.sw (fun () ->
+        Protocol.run_tcp_listener t.protocol;
+        `Stop_daemon)
 
   let shutdown t = Protocol.shutdown t.protocol
   let local_node t = Protocol.local_node t.protocol