+2 -1

.beads/issues.jsonl

··· 4 4 {"id":"swim-6ea","title":"Refactor codec to use Cstruct/Bigstringaf instead of string","description":"Current codec uses string for protocol buffers which causes unnecessary memory copies. Should use Cstruct or Bigstringaf buffers directly for zero-copy encoding/decoding. Key areas: encode_internal_msg, decode_internal_msg, Wire type conversions.","status":"closed","priority":2,"issue_type":"task","created_at":"2026-01-08T21:39:36.33328134+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T21:59:49.335638629+01:00","closed_at":"2026-01-08T21:59:49.335638629+01:00","close_reason":"Refactored codec to use Cstruct for zero-copy operations. All tests pass."} 5 5 {"id":"swim-7wx","title":"Make wire protocol compatible with HashiCorp memberlist","notes":"Final Status:\n\nCOMPLETED:\n- Unencrypted UDP ping/ack: WORKS\n- Encrypted UDP ping/ack (version 1 format): WORKS \n- Decryption of both v0 (PKCS7) and v1 messages: WORKS\n\nLIMITATION:\n- TCP Join() not supported (memberlist uses TCP for initial pushPull sync)\n- Nodes can still interoperate if seeded manually via add_member()\n\nFor full Serf/Consul compatibility, need to implement TCP listener.\nSee swim-tcp for TCP support tracking.","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-08T20:51:59.802585513+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T22:21:57.699683907+01:00","closed_at":"2026-01-08T22:21:57.699683907+01:00","close_reason":"Wire protocol compatibility achieved for UDP gossip (encrypted and unencrypted). TCP Join support tracked separately in swim-ffw."} 6 6 {"id":"swim-90e","title":"Implement transport.ml - Eio UDP/TCP networking","description":"Implement network transport layer using Eio.\n\n## UDP Transport\n\n### Functions\n- `create_udp_socket : Eio.Net.t -\u003e addr:string -\u003e port:int -\u003e Eio.Net.datagram_socket`\n- `send_udp : Eio.Net.datagram_socket -\u003e Eio.Net.Sockaddr.datagram -\u003e Cstruct.t -\u003e unit`\n- `recv_udp : Eio.Net.datagram_socket -\u003e Cstruct.t -\u003e (int * Eio.Net.Sockaddr.datagram)`\n\n## TCP Transport (for large payloads)\n\n### Functions\n- `create_tcp_listener : Eio.Net.t -\u003e addr:string -\u003e port:int -\u003e Eio.Net.listening_socket`\n- `connect_tcp : Eio.Net.t -\u003e addr:Eio.Net.Sockaddr.stream -\u003e timeout:float -\u003e clock:Eio.Time.clock -\u003e (Eio.Net.stream_socket, send_error) result`\n- `send_tcp : Eio.Net.stream_socket -\u003e Cstruct.t -\u003e (unit, send_error) result`\n- `recv_tcp : Eio.Net.stream_socket -\u003e Cstruct.t -\u003e (int, [`Connection_reset]) result`\n\n## Address parsing\n- `parse_addr : string -\u003e (Eio.Net.Sockaddr.datagram, [`Invalid_addr]) result`\n - Parse \"host:port\" format\n\n## Design constraints\n- Use Eio.Net for all I/O\n- No blocking except Eio primitives\n- Proper error handling via Result\n- Support for IPv4 and IPv6","acceptance_criteria":"- UDP send/recv works\n- TCP connect/send/recv works\n- Proper error handling\n- Address parsing robust","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:48:09.296035344+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:39:34.082898832+01:00","closed_at":"2026-01-08T19:39:34.082898832+01:00","close_reason":"Implemented UDP and TCP transport with Eio.Net, plus address parsing (mli skipped due to complex Eio row types)","labels":["core","eio","transport"],"dependencies":[{"issue_id":"swim-90e","depends_on_id":"swim-oun","type":"blocks","created_at":"2026-01-08T18:48:09.299855321+01:00","created_by":"gdiazlo"},{"issue_id":"swim-90e","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:48:15.52111057+01:00","created_by":"gdiazlo"}]} 7 7 - {"id":"swim-don","title":"Implement benchmarks (bench/)","description":"Performance benchmarks for critical paths.\n\n## bench/bench_codec.ml\n- `bench_encode_ping` - encoding a Ping message\n- `bench_encode_packet` - full packet with piggyback\n- `bench_decode_packet` - decoding a packet\n- `bench_encoded_size` - size calculation\n\n## bench/bench_crypto.ml\n- `bench_encrypt` - encryption throughput\n- `bench_decrypt` - decryption throughput\n- `bench_key_init` - key initialization\n\n## bench/bench_throughput.ml\n- `bench_broadcast_throughput` - messages/second\n- `bench_probe_cycle` - probe cycle latency\n- `bench_concurrent_probes` - parallel probe handling\n\n## bench/bench_allocations.ml\n- `bench_probe_cycle_allocations` - count allocations per probe\n- `bench_buffer_reuse_rate` - % of buffers reused\n- `bench_message_handling_allocations` - allocations per message\n\n## Performance targets to verify\n- \u003c 5 allocations per probe cycle\n- \u003e 95% buffer reuse rate\n- \u003c 3 seconds failure detection\n- \u003e 10,000 broadcast/sec\n- \u003c 1% CPU idle, \u003c 5% under load\n\n## Design constraints\n- Use core_bench or similar\n- Warm up before measuring\n- Multiple iterations for stability\n- Report with confidence intervals","acceptance_criteria":"- All benchmarks run\n- Performance targets documented\n- Regression detection possible\n- Results reproducible","status":"open","priority":3,"issue_type":"task","created_at":"2026-01-08T18:50:57.818433013+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T18:50:57.818433013+01:00","labels":["bench","performance"],"dependencies":[{"issue_id":"swim-don","depends_on_id":"swim-zsi","type":"blocks","created_at":"2026-01-08T18:50:57.821397737+01:00","created_by":"gdiazlo"},{"issue_id":"swim-don","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:51:03.066326187+01:00","created_by":"gdiazlo"}]} 7 7 + {"id":"swim-don","title":"Implement benchmarks (bench/)","description":"Performance benchmarks for critical paths.\n\n## bench/bench_codec.ml\n- `bench_encode_ping` - encoding a Ping message\n- `bench_encode_packet` - full packet with piggyback\n- `bench_decode_packet` - decoding a packet\n- `bench_encoded_size` - size calculation\n\n## bench/bench_crypto.ml\n- `bench_encrypt` - encryption throughput\n- `bench_decrypt` - decryption throughput\n- `bench_key_init` - key initialization\n\n## bench/bench_throughput.ml\n- `bench_broadcast_throughput` - messages/second\n- `bench_probe_cycle` - probe cycle latency\n- `bench_concurrent_probes` - parallel probe handling\n\n## bench/bench_allocations.ml\n- `bench_probe_cycle_allocations` - count allocations per probe\n- `bench_buffer_reuse_rate` - % of buffers reused\n- `bench_message_handling_allocations` - allocations per message\n\n## Performance targets to verify\n- \u003c 5 allocations per probe cycle\n- \u003e 95% buffer reuse rate\n- \u003c 3 seconds failure detection\n- \u003e 10,000 broadcast/sec\n- \u003c 1% CPU idle, \u003c 5% under load\n\n## Design constraints\n- Use core_bench or similar\n- Warm up before measuring\n- Multiple iterations for stability\n- Report with confidence intervals","acceptance_criteria":"- All benchmarks run\n- Performance targets documented\n- Regression detection possible\n- Results reproducible","status":"closed","priority":3,"issue_type":"task","created_at":"2026-01-08T18:50:57.818433013+01:00","created_by":"gdiazlo","updated_at":"2026-01-09T00:08:02.021391851+01:00","closed_at":"2026-01-09T00:08:02.021391851+01:00","close_reason":"Benchmarks fully working with parallel execution, all 3 implementations (swim-ocaml, memberlist, serf) communicate and measure properly","labels":["bench","performance"],"dependencies":[{"issue_id":"swim-don","depends_on_id":"swim-zsi","type":"blocks","created_at":"2026-01-08T18:50:57.821397737+01:00","created_by":"gdiazlo"},{"issue_id":"swim-don","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:51:03.066326187+01:00","created_by":"gdiazlo"}]} 8 8 {"id":"swim-etm","title":"Implement pending_acks.ml - Ack tracking with promises","description":"Implement pending ack tracking for probe responses.\n\n## Pending_acks module\n```ocaml\ntype waiter = {\n promise : string option Eio.Promise.t;\n resolver : string option Eio.Promise.u;\n}\n\ntype t = {\n table : (int, waiter) Kcas_data.Hashtbl.t;\n}\n```\n\n### Functions\n- `create : unit -\u003e t`\n\n- `register : t -\u003e seq:int -\u003e waiter`\n - Create promise/resolver pair\n - Store in hashtable keyed by sequence number\n - Return waiter handle\n\n- `complete : t -\u003e seq:int -\u003e payload:string option -\u003e bool`\n - Find waiter by seq\n - Resolve promise with payload\n - Remove from table\n - Return true if found\n\n- `wait : waiter -\u003e timeout:float -\u003e clock:Eio.Time.clock -\u003e string option option`\n - Wait for promise with timeout\n - Return Some payload on success\n - Return None on timeout\n\n- `cancel : t -\u003e seq:int -\u003e unit`\n - Remove waiter from table\n - Called on timeout to cleanup\n\n## Design constraints\n- Use Eio.Promise for async waiting\n- Use Eio.Time.with_timeout for timeouts\n- Lock-free via Kcas_data.Hashtbl\n- Cleanup on timeout to prevent leaks","acceptance_criteria":"- Acks properly matched to probes\n- Timeouts work correctly\n- No memory leaks on timeout\n- Concurrent completion safe","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:47:51.390307674+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:35:56.984403853+01:00","closed_at":"2026-01-08T19:35:56.984403853+01:00","close_reason":"Implemented pending_acks with Eio.Promise for async waiting and Kcas_data.Hashtbl for lock-free storage","labels":["core","kcas","protocol"],"dependencies":[{"issue_id":"swim-etm","depends_on_id":"swim-oun","type":"blocks","created_at":"2026-01-08T18:47:51.394677184+01:00","created_by":"gdiazlo"},{"issue_id":"swim-etm","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:47:57.657173744+01:00","created_by":"gdiazlo"}]} 9 9 {"id":"swim-fac","title":"Implement protocol_pure.ml - Pure SWIM state transitions","description":"Implement pure (no effects) SWIM protocol logic for state transitions.\n\n## Core abstraction\n```ocaml\ntype 'a transition = {\n new_state : 'a;\n broadcasts : protocol_msg list;\n events : node_event list;\n}\n```\n\n## State transition functions\n- `handle_alive : member_state -\u003e alive_msg -\u003e now:float -\u003e member_state transition`\n- `handle_suspect : member_state -\u003e suspect_msg -\u003e now:float -\u003e member_state transition`\n- `handle_dead : member_state -\u003e dead_msg -\u003e now:float -\u003e member_state transition`\n- `handle_ack : probe_state -\u003e ack_msg -\u003e probe_state transition`\n\n## Timeout calculations\n- `suspicion_timeout : config -\u003e node_count:int -\u003e float`\n - Based on suspicion_mult and log(node_count)\n - Capped by suspicion_max_timeout\n\n## Probe target selection\n- `next_probe_target : probe_index:int -\u003e members:node list -\u003e (node * int) option`\n - Round-robin with wraparound\n - Skip self\n\n## Message invalidation (for queue pruning)\n- `invalidates : protocol_msg -\u003e protocol_msg -\u003e bool`\n - Alive invalidates Suspect for same node with \u003e= incarnation\n - Dead invalidates everything for same node\n - Suspect invalidates older Suspect\n\n## State merging\n- `merge_member_state : local:member_state -\u003e remote:member_state -\u003e member_state`\n - CRDT-style merge based on incarnation\n - Dead is final (tombstone)\n - Higher incarnation wins\n\n## Retransmit calculation\n- `retransmit_limit : config -\u003e node_count:int -\u003e int`\n - Based on retransmit_mult * ceil(log(node_count + 1))\n\n## Design constraints\n- PURE functions only - no I/O, no time, no randomness\n- All inputs explicit\n- Exhaustive pattern matching\n- Fully testable with property-based tests","acceptance_criteria":"- All functions are pure (no effects)\n- Property-based tests for SWIM invariants\n- Incarnation ordering correct\n- Suspicion timeout formula matches SWIM paper","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:46:48.400928801+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:29:29.816719466+01:00","closed_at":"2026-01-08T19:29:29.816719466+01:00","close_reason":"Implemented all pure SWIM state transitions: handle_alive, handle_suspect, handle_dead, suspicion_timeout, retransmit_limit, next_probe_target, invalidates, merge_member_state, select_indirect_targets","labels":["core","protocol","pure"],"dependencies":[{"issue_id":"swim-fac","depends_on_id":"swim-td8","type":"blocks","created_at":"2026-01-08T18:46:48.40501031+01:00","created_by":"gdiazlo"},{"issue_id":"swim-fac","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:46:52.770706917+01:00","created_by":"gdiazlo"}]} 10 10 {"id":"swim-ffw","title":"Add TCP listener for memberlist Join() compatibility","description":"Memberlist uses TCP for the initial Join() pushPull state sync.\nCurrently OCaml SWIM only has UDP, so memberlist nodes cannot Join() to us.\n\nRequirements:\n1. TCP listener on bind_port (same as UDP)\n2. Handle pushPull state exchange messages\n3. Support encrypted TCP connections\n\nWire format for TCP is same as UDP but with length prefix.\n\nReference: hashicorp/memberlist net.go sendAndReceiveState()","status":"closed","priority":2,"issue_type":"feature","created_at":"2026-01-08T22:21:40.02285377+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T22:43:27.425951418+01:00","closed_at":"2026-01-08T22:43:27.425951418+01:00","close_reason":"Implemented TCP listener for memberlist Join() compatibility"} 11 11 {"id":"swim-hc9","title":"Implement crypto.ml - AES-256-GCM encryption","description":"Implement encryption layer using mirage-crypto for AES-256-GCM.\n\n## Constants\n- `nonce_size = 12`\n- `tag_size = 16`\n- `overhead = nonce_size + tag_size` (28 bytes)\n\n## Functions\n\n### Key initialization\n- `init_key : string -\u003e (key, [`Invalid_key_length]) result`\n- Must be exactly 32 bytes for AES-256\n\n### Encryption\n- `encrypt : key -\u003e Cstruct.t -\u003e Cstruct.t`\n- Generate random nonce via mirage-crypto-rng\n- Prepend nonce to ciphertext\n- Result: nonce (12) + ciphertext + tag (16)\n\n### Decryption\n- `decrypt : key -\u003e Cstruct.t -\u003e (Cstruct.t, [`Too_short | `Decryption_failed]) result`\n- Extract nonce from first 12 bytes\n- Verify and decrypt remaining data\n- Return plaintext or error\n\n## Design constraints\n- Use mirage-crypto.Cipher_block.AES.GCM\n- Use mirage-crypto-rng for nonce generation\n- Return Result types, no exceptions\n- Consider in-place decryption where possible","acceptance_criteria":"- Property-based roundtrip tests pass\n- Invalid data properly rejected\n- Key validation works\n- Nonces are unique (use RNG)","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:46:09.946405585+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:24:49.736202746+01:00","closed_at":"2026-01-08T19:24:49.736202746+01:00","close_reason":"Implemented crypto.ml with AES-256-GCM using mirage-crypto. Uses Eio.Flow for secure random nonce generation.","labels":["core","crypto","security"],"dependencies":[{"issue_id":"swim-hc9","depends_on_id":"swim-oun","type":"blocks","created_at":"2026-01-08T18:46:09.950083952+01:00","created_by":"gdiazlo"},{"issue_id":"swim-hc9","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:46:14.608204384+01:00","created_by":"gdiazlo"}]} 12 12 + {"id":"swim-hrd","title":"Optimize memory allocation in TCP handler and LZW","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T23:01:20.712060651+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T23:07:38.188801028+01:00","closed_at":"2026-01-08T23:07:38.188801028+01:00","close_reason":"Memory optimization complete"} 12 13 {"id":"swim-iwg","title":"Implement dissemination.ml - Broadcast queue with invalidation","description":"Implement the broadcast queue for SWIM protocol message dissemination.\n\n## Broadcast_queue module\n```ocaml\ntype item = {\n msg : protocol_msg;\n transmits : int Kcas.Loc.t;\n created : Mtime.span;\n}\n\ntype t = {\n queue : item Kcas_data.Queue.t;\n depth : int Kcas.Loc.t;\n}\n```\n\n### Functions\n- `create : unit -\u003e t`\n\n- `enqueue : t -\u003e protocol_msg -\u003e transmits:int -\u003e created:Mtime.span -\u003e unit`\n - Add message with initial transmit count\n - Increment depth\n\n- `drain : t -\u003e max_bytes:int -\u003e encode_size:(protocol_msg -\u003e int) -\u003e protocol_msg list`\n - Pop messages up to max_bytes\n - Decrement transmit count\n - Re-enqueue if transmits \u003e 0\n - Return list of messages to piggyback\n\n- `depth : t -\u003e int`\n\n- `invalidate : t -\u003e invalidates:(protocol_msg -\u003e protocol_msg -\u003e bool) -\u003e protocol_msg -\u003e unit`\n - Remove messages invalidated by newer message\n - Uses Protocol_pure.invalidates\n\n## Design constraints\n- Lock-free via Kcas_data.Queue\n- Transmit counting for reliable dissemination\n- Size-aware draining for UDP packet limits\n- Message invalidation to prune stale updates","acceptance_criteria":"- Messages properly disseminated\n- Transmit counts respected\n- Invalidation works correctly\n- No message loss during concurrent access","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:47:32.926237507+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:34:04.973053383+01:00","closed_at":"2026-01-08T19:34:04.973053383+01:00","close_reason":"Implemented broadcast queue with enqueue, drain (size-aware), and invalidate functions using Kcas_data.Queue","labels":["core","dissemination","kcas"],"dependencies":[{"issue_id":"swim-iwg","depends_on_id":"swim-td8","type":"blocks","created_at":"2026-01-08T18:47:32.933998652+01:00","created_by":"gdiazlo"},{"issue_id":"swim-iwg","depends_on_id":"swim-fac","type":"blocks","created_at":"2026-01-08T18:47:32.93580631+01:00","created_by":"gdiazlo"},{"issue_id":"swim-iwg","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:47:40.222942145+01:00","created_by":"gdiazlo"}]} 13 14 {"id":"swim-l32","title":"Implement codec tests (test/test_codec.ml)","description":"Property-based and unit tests for codec module.\n\n## Property tests\n\n### Roundtrip\n- `test_codec_roundtrip` - encode then decode equals original\n- `test_encoder_decoder_roundtrip` - for primitive types\n\n### Size calculation\n- `test_encoded_size_accurate` - encoded_size matches actual encoding\n\n### Error handling\n- `test_invalid_magic_rejected`\n- `test_unsupported_version_rejected`\n- `test_truncated_message_rejected`\n- `test_invalid_tag_rejected`\n\n## Unit tests\n\n### Encoder\n- Test write_byte, write_int16_be, etc.\n- Test write_string with various lengths\n- Test buffer overflow detection\n\n### Decoder\n- Test read operations\n- Test remaining/is_empty\n- Test boundary conditions\n\n### Message encoding\n- Test each message type individually\n- Test packet with piggyback messages\n- Test empty piggyback list\n\n## Design constraints\n- Use QCheck for property tests\n- Use Alcotest or similar for unit tests\n- Cover all message types\n- Test error paths","acceptance_criteria":"- All property tests pass\n- All unit tests pass\n- Edge cases covered\n- Error handling tested","status":"closed","priority":2,"issue_type":"task","created_at":"2026-01-08T18:49:38.017959466+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T20:03:07.370600701+01:00","closed_at":"2026-01-08T20:03:07.370600701+01:00","close_reason":"Implemented codec property and unit tests - all 19 tests passing","labels":["codec","test"],"dependencies":[{"issue_id":"swim-l32","depends_on_id":"swim-l5y","type":"blocks","created_at":"2026-01-08T18:49:38.021527282+01:00","created_by":"gdiazlo"},{"issue_id":"swim-l32","depends_on_id":"swim-294","type":"blocks","created_at":"2026-01-08T18:49:38.02331756+01:00","created_by":"gdiazlo"},{"issue_id":"swim-l32","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:49:42.065502393+01:00","created_by":"gdiazlo"}]} 14 15 {"id":"swim-l5y","title":"Implement codec.ml - Zero-copy binary encoding/decoding","description":"Implement binary encoding/decoding with zero-copy semantics using Cstruct.\n\n## Components\n\n### Encoder module\n- `type t` with buf and mutable pos\n- `create : buf:Cstruct.t -\u003e t`\n- `write_byte`, `write_int16_be`, `write_int32_be`, `write_int64_be`\n- `write_string` (length-prefixed)\n- `write_bytes`\n- `to_cstruct` - returns view, no copy\n- `reset`, `remaining`\n\n### Decoder module\n- `type t` with buf and mutable pos\n- `create : Cstruct.t -\u003e t`\n- `read_byte`, `read_int16_be`, `read_int32_be`, `read_int64_be`\n- `read_string` - returns string (must copy for safety)\n- `read_bytes` - returns Cstruct view\n- `remaining`, `is_empty`\n\n### Codec module\n- Magic bytes: \"SWIM\"\n- Version: 1\n- Message tags: 0x01-0x07 for each message type\n- `encode_packet : packet -\u003e buf:Cstruct.t -\u003e (int, [`Buffer_too_small]) result`\n- `decode_packet : Cstruct.t -\u003e packet decode_result`\n- `encoded_size : protocol_msg -\u003e int` for queue draining\n\n### Helper encoders\n- `encode_node`, `encode_node_id`\n- `encode_option`\n- `decode_msg`\n\n## Design constraints\n- No allocations in hot path except unavoidable string creation\n- Return Result types, no exceptions\n- Use Cstruct sub-views where possible","acceptance_criteria":"- Property-based roundtrip tests pass\n- No unnecessary allocations\n- All message types encode/decode correctly\n- Error handling for truncated/invalid data","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-08T18:45:54.407900731+01:00","created_by":"gdiazlo","updated_at":"2026-01-08T19:23:12.726852552+01:00","closed_at":"2026-01-08T19:23:12.726852552+01:00","close_reason":"Implemented codec.ml with Encoder/Decoder modules, zero-copy encoding/decoding for all protocol messages, IP address parsing, and encoded_size calculation","labels":["codec","core","zero-copy"],"dependencies":[{"issue_id":"swim-l5y","depends_on_id":"swim-td8","type":"blocks","created_at":"2026-01-08T18:45:54.412742463+01:00","created_by":"gdiazlo"},{"issue_id":"swim-l5y","depends_on_id":"swim-wdc","type":"parent-child","created_at":"2026-01-08T18:45:59.779010836+01:00","created_by":"gdiazlo"}]}

-40

AGENTS.md

··· 1 1 - # Agent Instructions 2 2 - 3 3 - This project uses **bd** (beads) for issue tracking. Run `bd onboard` to get started. 4 4 - 5 5 - ## Quick Reference 6 6 - 7 7 - ```bash 8 8 - bd ready # Find available work 9 9 - bd show <id> # View issue details 10 10 - bd update <id> --status in_progress # Claim work 11 11 - bd close <id> # Complete work 12 12 - bd sync # Sync with git 13 13 - ``` 14 14 - 15 15 - ## Landing the Plane (Session Completion) 16 16 - 17 17 - **When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds. 18 18 - 19 19 - **MANDATORY WORKFLOW:** 20 20 - 21 21 - 1. **File issues for remaining work** - Create issues for anything that needs follow-up 22 22 - 2. **Run quality gates** (if code changed) - Tests, linters, builds 23 23 - 3. **Update issue status** - Close finished work, update in-progress items 24 24 - 4. **PUSH TO REMOTE** - This is MANDATORY: 25 25 - ```bash 26 26 - git pull --rebase 27 27 - bd sync 28 28 - git push 29 29 - git status # MUST show "up to date with origin" 30 30 - ``` 31 31 - 5. **Clean up** - Clear stashes, prune remote branches 32 32 - 6. **Verify** - All changes committed AND pushed 33 33 - 7. **Hand off** - Provide context for next session 34 34 - 35 35 - **CRITICAL RULES:** 36 36 - - Work is NOT complete until `git push` succeeds 37 37 - - NEVER stop before pushing - that leaves work stranded locally 38 38 - - NEVER say "ready to push when you are" - YOU must push 39 39 - - If push fails, resolve and retry until it succeeds 40 40 -

+177

README.md

··· 1 1 + # swim 2 2 + 3 3 + An OCaml 5 implementation of the SWIM (Scalable Weakly-consistent Infection-style Process Group Membership) protocol for cluster membership and failure detection. 4 4 + 5 5 + ## Overview 6 6 + 7 7 + This library provides: 8 8 + 9 9 + - **Membership Management**: Automatic discovery and tracking of cluster nodes 10 10 + - **Failure Detection**: Identifies unreachable nodes using periodic probes and indirect checks 11 11 + - **Gossip Protocol**: Propagates state changes (Alive/Suspect/Dead) across the cluster 12 12 + - **Messaging**: Cluster-wide broadcast (gossip-based) and direct point-to-point UDP messaging 13 13 + - **Encryption**: Optional AES-256-GCM encryption for all network traffic 14 14 + 15 15 + Built on [Eio](https://github.com/ocaml-multicore/eio) for effect-based concurrency and [Kcas](https://github.com/ocaml-multicore/kcas) for lock-free shared state. 16 16 + 17 17 + ## Requirements 18 18 + 19 19 + - OCaml >= 5.1 20 20 + - Dune >= 3.20 21 21 + 22 22 + ## Installation 23 23 + 24 24 + ```bash 25 25 + opam install . 26 26 + ``` 27 27 + 28 28 + Or add to your dune-project: 29 29 + 30 30 + ``` 31 31 + (depends (swim (>= 0.1.0))) 32 32 + ``` 33 33 + 34 34 + ## Usage 35 35 + 36 36 + ### Basic Example 37 37 + 38 38 + ```ocaml 39 39 + open Swim.Types 40 40 + 41 41 + let config = { 42 42 + default_config with 43 43 + bind_port = 7946; 44 44 + node_name = Some "node-1"; 45 45 + secret_key = "your-32-byte-secret-key-here!!!"; (* 32 bytes for AES-256 *) 46 46 + encryption_enabled = true; 47 47 + } 48 48 + 49 49 + let () = 50 50 + Eio_main.run @@ fun env -> 51 51 + Eio.Switch.run @@ fun sw -> 52 52 + let env_wrap = { stdenv = env; sw } in 53 53 + match Swim.Cluster.create ~sw ~env:env_wrap ~config with 54 54 + | Error `Invalid_key -> failwith "Invalid secret key" 55 55 + | Ok cluster -> 56 56 + Swim.Cluster.start cluster; 57 57 + 58 58 + (* Join an existing cluster *) 59 59 + let seed_nodes = ["192.168.1.10:7946"] in 60 60 + (match Swim.Cluster.join cluster ~seed_nodes with 61 61 + | Ok () -> Printf.printf "Joined cluster\n" 62 62 + | Error `No_seeds_reachable -> Printf.printf "Failed to join\n"); 63 63 + 64 64 + (* Send a broadcast message to all nodes *) 65 65 + Swim.Cluster.broadcast cluster ~topic:"config" ~payload:"v2"; 66 66 + 67 67 + (* Send a direct message to a specific node *) 68 68 + let target = node_id_of_string "node-2" in 69 69 + Swim.Cluster.send cluster ~target ~topic:"ping" ~payload:"hello"; 70 70 + 71 71 + (* Handle incoming messages *) 72 72 + Swim.Cluster.on_message cluster (fun sender topic payload -> 73 73 + Printf.printf "From %s: [%s] %s\n" 74 74 + (node_id_to_string sender.id) topic payload); 75 75 + 76 76 + (* Listen for membership events *) 77 77 + Eio.Fiber.fork ~sw (fun () -> 78 78 + let stream = Swim.Cluster.events cluster in 79 79 + while true do 80 80 + match Eio.Stream.take stream with 81 81 + | Join node -> Printf.printf "Joined: %s\n" (node_id_to_string node.id) 82 82 + | Leave node -> Printf.printf "Left: %s\n" (node_id_to_string node.id) 83 83 + | Suspect_event node -> Printf.printf "Suspect: %s\n" (node_id_to_string node.id) 84 84 + | Alive_event node -> Printf.printf "Alive: %s\n" (node_id_to_string node.id) 85 85 + | Update _ -> () 86 86 + done); 87 87 + 88 88 + Eio.Fiber.await_cancel () 89 89 + ``` 90 90 + 91 91 + ### Configuration Options 92 92 + 93 93 + | Field | Default | Description | 94 94 + |-------|---------|-------------| 95 95 + | `bind_addr` | "0.0.0.0" | Interface to bind listeners | 96 96 + | `bind_port` | 7946 | Port for SWIM protocol | 97 97 + | `protocol_interval` | 1.0 | Seconds between probe rounds | 98 98 + | `probe_timeout` | 0.5 | Seconds to wait for Ack | 99 99 + | `indirect_checks` | 3 | Peers to ask for indirect probes | 100 100 + | `secret_key` | (zeros) | 32-byte key for AES-256-GCM | 101 101 + | `encryption_enabled` | false | Enable encryption | 102 102 + 103 103 + ## Interoperability Testing 104 104 + 105 105 + The library includes interoperability tests with HashiCorp's [memberlist](https://github.com/hashicorp/memberlist) (Go). This verifies protocol compatibility with the reference implementation. 106 106 + 107 107 + ### Prerequisites 108 108 + 109 109 + - Go >= 1.19 110 110 + - OCaml environment with dune 111 111 + 112 112 + ### Running Interop Tests 113 113 + 114 114 + The interop test suite starts a Go memberlist node and an OCaml node, then verifies they can discover each other and exchange messages. 115 115 + 116 116 + ```bash 117 117 + # Build the OCaml project 118 118 + dune build 119 119 + 120 120 + # Build the Go memberlist server 121 121 + cd interop && go build -o memberlist-server main.go && cd .. 122 122 + 123 123 + # Run the interop test 124 124 + bash test/scripts/test_interop.sh 125 125 + 126 126 + # Run with encryption enabled 127 127 + bash test/scripts/test_interop_encrypted.sh 128 128 + ``` 129 129 + 130 130 + ### Manual Interop Testing 131 131 + 132 132 + Start the Go node: 133 133 + 134 134 + ```bash 135 135 + cd interop 136 136 + go run main.go -name go-node -bind 127.0.0.1 -port 7946 137 137 + ``` 138 138 + 139 139 + In another terminal, start the OCaml node: 140 140 + 141 141 + ```bash 142 142 + dune exec swim-interop-test 143 143 + ``` 144 144 + 145 145 + The OCaml node will connect to the Go node and print membership statistics for 30 seconds. 146 146 + 147 147 + ### Available Test Scripts 148 148 + 149 149 + | Script | Description | 150 150 + |--------|-------------| 151 151 + | `test/scripts/test_interop.sh` | Basic interop test | 152 152 + | `test/scripts/test_interop_encrypted.sh` | Interop with AES encryption | 153 153 + | `test/scripts/test_interop_udp_only.sh` | UDP-only communication test | 154 154 + | `test/scripts/test_interop_go_joins.sh` | Go node joining OCaml cluster | 155 155 + 156 156 + ### Debug Utilities 157 157 + 158 158 + ```bash 159 159 + # Test packet encoding/decoding 160 160 + dune exec swim-debug-codec 161 161 + 162 162 + # Receive and display incoming SWIM packets 163 163 + dune exec swim-debug-recv 164 164 + 165 165 + # Send manual ping to a target node 166 166 + dune exec swim-debug-ping 167 167 + ``` 168 168 + 169 169 + ## Running Tests 170 170 + 171 171 + ```bash 172 172 + dune runtest 173 173 + ``` 174 174 + 175 175 + ## License 176 176 + 177 177 + ISC License. See [LICENSE](LICENSE) for details.

+3

bench/.gitignore

··· 1 1 + bin/ 2 2 + results/ 3 3 + go.sum

+261

bench/cmd/memberlist/main.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "flag" 6 6 + "fmt" 7 7 + "log" 8 8 + "net" 9 9 + "os" 10 10 + "runtime" 11 11 + "sync" 12 12 + "sync/atomic" 13 13 + "time" 14 14 + 15 15 + "github.com/hashicorp/memberlist" 16 16 + ) 17 17 + 18 18 + type BenchmarkResult struct { 19 19 + Implementation string `json:"implementation"` 20 20 + NumNodes int `json:"num_nodes"` 21 21 + Duration time.Duration `json:"duration_ns"` 22 22 + MessagesReceived int64 `json:"messages_received"` 23 23 + MessagesSent int64 `json:"messages_sent"` 24 24 + ConvergenceTime time.Duration `json:"convergence_time_ns"` 25 25 + MemoryUsedBytes uint64 `json:"memory_used_bytes"` 26 26 + GoroutinesUsed int `json:"goroutines_used"` 27 27 + CPUCores int `json:"cpu_cores"` 28 28 + } 29 29 + 30 30 + type benchDelegate struct { 31 31 + received atomic.Int64 32 32 + sent atomic.Int64 33 33 + meta []byte 34 34 + } 35 35 + 36 36 + func (d *benchDelegate) NodeMeta(limit int) []byte { 37 37 + return d.meta 38 38 + } 39 39 + 40 40 + func (d *benchDelegate) NotifyMsg(msg []byte) { 41 41 + d.received.Add(1) 42 42 + } 43 43 + 44 44 + func (d *benchDelegate) GetBroadcasts(overhead, limit int) [][]byte { 45 45 + return nil 46 46 + } 47 47 + 48 48 + func (d *benchDelegate) LocalState(join bool) []byte { 49 49 + return nil 50 50 + } 51 51 + 52 52 + func (d *benchDelegate) MergeRemoteState(buf []byte, join bool) { 53 53 + } 54 54 + 55 55 + type benchEventDelegate struct { 56 56 + joinCh chan string 57 57 + mu sync.Mutex 58 58 + joined map[string]bool 59 59 + } 60 60 + 61 61 + func newBenchEventDelegate() *benchEventDelegate { 62 62 + return &benchEventDelegate{ 63 63 + joinCh: make(chan string, 1000), 64 64 + joined: make(map[string]bool), 65 65 + } 66 66 + } 67 67 + 68 68 + func (e *benchEventDelegate) NotifyJoin(node *memberlist.Node) { 69 69 + e.mu.Lock() 70 70 + if !e.joined[node.Name] { 71 71 + e.joined[node.Name] = true 72 72 + select { 73 73 + case e.joinCh <- node.Name: 74 74 + default: 75 75 + } 76 76 + } 77 77 + e.mu.Unlock() 78 78 + } 79 79 + 80 80 + func (e *benchEventDelegate) NotifyLeave(node *memberlist.Node) {} 81 81 + func (e *benchEventDelegate) NotifyUpdate(node *memberlist.Node) {} 82 82 + 83 83 + func (e *benchEventDelegate) waitForNodes(n int, timeout time.Duration) bool { 84 84 + deadline := time.Now().Add(timeout) 85 85 + for { 86 86 + e.mu.Lock() 87 87 + count := len(e.joined) 88 88 + e.mu.Unlock() 89 89 + if count >= n { 90 90 + return true 91 91 + } 92 92 + if time.Now().After(deadline) { 93 93 + return false 94 94 + } 95 95 + time.Sleep(10 * time.Millisecond) 96 96 + } 97 97 + } 98 98 + 99 99 + func createMemberlistNode(name string, port int, delegate *benchDelegate, events *benchEventDelegate) (*memberlist.Memberlist, error) { 100 100 + cfg := memberlist.DefaultLANConfig() 101 101 + cfg.Name = name 102 102 + cfg.BindAddr = "127.0.0.1" 103 103 + cfg.BindPort = port 104 104 + cfg.AdvertisePort = port 105 105 + cfg.Delegate = delegate 106 106 + cfg.Events = events 107 107 + cfg.LogOutput = os.Stderr 108 108 + cfg.GossipInterval = 100 * time.Millisecond 109 109 + cfg.ProbeInterval = 500 * time.Millisecond 110 110 + cfg.PushPullInterval = 15 * time.Second 111 111 + cfg.GossipNodes = 3 112 112 + 113 113 + return memberlist.Create(cfg) 114 114 + } 115 115 + 116 116 + func runMemberlistBenchmark(numNodes int, duration time.Duration) (*BenchmarkResult, error) { 117 117 + var memBefore runtime.MemStats 118 118 + runtime.GC() 119 119 + runtime.ReadMemStats(&memBefore) 120 120 + goroutinesBefore := runtime.NumGoroutine() 121 121 + 122 122 + nodes := make([]*memberlist.Memberlist, numNodes) 123 123 + delegates := make([]*benchDelegate, numNodes) 124 124 + eventDelegates := make([]*benchEventDelegate, numNodes) 125 125 + 126 126 + basePort := 17946 127 127 + 128 128 + for i := 0; i < numNodes; i++ { 129 129 + delegates[i] = &benchDelegate{meta: []byte(fmt.Sprintf("node-%d", i))} 130 130 + eventDelegates[i] = newBenchEventDelegate() 131 131 + 132 132 + var err error 133 133 + nodes[i], err = createMemberlistNode( 134 134 + fmt.Sprintf("node-%d", i), 135 135 + basePort+i, 136 136 + delegates[i], 137 137 + eventDelegates[i], 138 138 + ) 139 139 + if err != nil { 140 140 + for j := 0; j < i; j++ { 141 141 + nodes[j].Shutdown() 142 142 + } 143 143 + return nil, fmt.Errorf("failed to create node %d: %w", i, err) 144 144 + } 145 145 + } 146 146 + 147 147 + convergenceStart := time.Now() 148 148 + 149 149 + for i := 1; i < numNodes; i++ { 150 150 + addr := fmt.Sprintf("127.0.0.1:%d", basePort) 151 151 + _, err := nodes[i].Join([]string{addr}) 152 152 + if err != nil { 153 153 + log.Printf("Warning: node %d failed to join: %v", i, err) 154 154 + } 155 155 + } 156 156 + 157 157 + allConverged := true 158 158 + for i := 0; i < numNodes; i++ { 159 159 + if !eventDelegates[i].waitForNodes(numNodes, 30*time.Second) { 160 160 + allConverged = false 161 161 + log.Printf("Node %d did not see all %d nodes", i, numNodes) 162 162 + } 163 163 + } 164 164 + 165 165 + convergenceTime := time.Since(convergenceStart) 166 166 + if !allConverged { 167 167 + log.Printf("Warning: not all nodes converged within timeout") 168 168 + } 169 169 + 170 170 + stopBroadcast := make(chan struct{}) 171 171 + var wg sync.WaitGroup 172 172 + wg.Add(1) 173 173 + go func() { 174 174 + defer wg.Done() 175 175 + ticker := time.NewTicker(100 * time.Millisecond) 176 176 + defer ticker.Stop() 177 177 + msg := []byte("benchmark-message") 178 178 + for { 179 179 + select { 180 180 + case <-ticker.C: 181 181 + for i, n := range nodes { 182 182 + n.SendBestEffort(n.LocalNode(), msg) 183 183 + delegates[i].sent.Add(1) 184 184 + } 185 185 + case <-stopBroadcast: 186 186 + return 187 187 + } 188 188 + } 189 189 + }() 190 190 + 191 191 + time.Sleep(duration) 192 192 + close(stopBroadcast) 193 193 + wg.Wait() 194 194 + 195 195 + var memAfter runtime.MemStats 196 196 + runtime.ReadMemStats(&memAfter) 197 197 + goroutinesAfter := runtime.NumGoroutine() 198 198 + 199 199 + var totalReceived, totalSent int64 200 200 + for _, d := range delegates { 201 201 + totalReceived += d.received.Load() 202 202 + totalSent += d.sent.Load() 203 203 + } 204 204 + 205 205 + for _, n := range nodes { 206 206 + n.Shutdown() 207 207 + } 208 208 + 209 209 + return &BenchmarkResult{ 210 210 + Implementation: "memberlist", 211 211 + NumNodes: numNodes, 212 212 + Duration: duration, 213 213 + MessagesReceived: totalReceived, 214 214 + MessagesSent: totalSent, 215 215 + ConvergenceTime: convergenceTime, 216 216 + MemoryUsedBytes: memAfter.HeapAlloc - memBefore.HeapAlloc, 217 217 + GoroutinesUsed: goroutinesAfter - goroutinesBefore, 218 218 + CPUCores: runtime.NumCPU(), 219 219 + }, nil 220 220 + } 221 221 + 222 222 + func getFreePort() (int, error) { 223 223 + addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0") 224 224 + if err != nil { 225 225 + return 0, err 226 226 + } 227 227 + l, err := net.ListenTCP("tcp", addr) 228 228 + if err != nil { 229 229 + return 0, err 230 230 + } 231 231 + defer l.Close() 232 232 + return l.Addr().(*net.TCPAddr).Port, nil 233 233 + } 234 234 + 235 235 + func main() { 236 236 + numNodes := flag.Int("nodes", 5, "number of nodes") 237 237 + durationSec := flag.Int("duration", 10, "benchmark duration in seconds") 238 238 + outputJSON := flag.Bool("json", false, "output as JSON") 239 239 + flag.Parse() 240 240 + 241 241 + result, err := runMemberlistBenchmark(*numNodes, time.Duration(*durationSec)*time.Second) 242 242 + if err != nil { 243 243 + log.Fatalf("Benchmark failed: %v", err) 244 244 + } 245 245 + 246 246 + if *outputJSON { 247 247 + enc := json.NewEncoder(os.Stdout) 248 248 + enc.SetIndent("", " ") 249 249 + enc.Encode(result) 250 250 + } else { 251 251 + fmt.Printf("=== Memberlist Benchmark Results ===\n") 252 252 + fmt.Printf("Nodes: %d\n", result.NumNodes) 253 253 + fmt.Printf("Duration: %s\n", result.Duration) 254 254 + fmt.Printf("Convergence: %s\n", result.ConvergenceTime) 255 255 + fmt.Printf("Messages Recv: %d\n", result.MessagesReceived) 256 256 + fmt.Printf("Messages Sent: %d\n", result.MessagesSent) 257 257 + fmt.Printf("Memory Used: %.2f MB\n", float64(result.MemoryUsedBytes)/1024/1024) 258 258 + fmt.Printf("Goroutines: %d\n", result.GoroutinesUsed) 259 259 + fmt.Printf("CPU Cores: %d\n", result.CPUCores) 260 260 + } 261 261 + }

+247

bench/cmd/memberlist_throughput/main.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "flag" 6 6 + "fmt" 7 7 + "log" 8 8 + "os" 9 9 + "runtime" 10 10 + "sync" 11 11 + "sync/atomic" 12 12 + "time" 13 13 + 14 14 + "github.com/hashicorp/memberlist" 15 15 + ) 16 16 + 17 17 + type ThroughputResult struct { 18 18 + Implementation string `json:"implementation"` 19 19 + NumNodes int `json:"num_nodes"` 20 20 + DurationNs int64 `json:"duration_ns"` 21 21 + MsgRate int `json:"msg_rate"` 22 22 + BroadcastsSent int64 `json:"broadcasts_sent"` 23 23 + BroadcastsReceived int64 `json:"broadcasts_received"` 24 24 + MsgsPerSec float64 `json:"msgs_per_sec"` 25 25 + CPUCores int `json:"cpu_cores"` 26 26 + } 27 27 + 28 28 + type throughputDelegate struct { 29 29 + received atomic.Int64 30 30 + meta []byte 31 31 + } 32 32 + 33 33 + func (d *throughputDelegate) NodeMeta(limit int) []byte { 34 34 + return d.meta 35 35 + } 36 36 + 37 37 + func (d *throughputDelegate) NotifyMsg(msg []byte) { 38 38 + if len(msg) > 0 && msg[0] == 'B' { 39 39 + d.received.Add(1) 40 40 + } 41 41 + } 42 42 + 43 43 + func (d *throughputDelegate) GetBroadcasts(overhead, limit int) [][]byte { 44 44 + return nil 45 45 + } 46 46 + 47 47 + func (d *throughputDelegate) LocalState(join bool) []byte { 48 48 + return nil 49 49 + } 50 50 + 51 51 + func (d *throughputDelegate) MergeRemoteState(buf []byte, join bool) { 52 52 + } 53 53 + 54 54 + type throughputEventDelegate struct { 55 55 + joinCh chan string 56 56 + mu sync.Mutex 57 57 + joined map[string]bool 58 58 + } 59 59 + 60 60 + func newThroughputEventDelegate() *throughputEventDelegate { 61 61 + return &throughputEventDelegate{ 62 62 + joinCh: make(chan string, 1000), 63 63 + joined: make(map[string]bool), 64 64 + } 65 65 + } 66 66 + 67 67 + func (e *throughputEventDelegate) NotifyJoin(node *memberlist.Node) { 68 68 + e.mu.Lock() 69 69 + if !e.joined[node.Name] { 70 70 + e.joined[node.Name] = true 71 71 + select { 72 72 + case e.joinCh <- node.Name: 73 73 + default: 74 74 + } 75 75 + } 76 76 + e.mu.Unlock() 77 77 + } 78 78 + 79 79 + func (e *throughputEventDelegate) NotifyLeave(node *memberlist.Node) {} 80 80 + func (e *throughputEventDelegate) NotifyUpdate(node *memberlist.Node) {} 81 81 + 82 82 + func (e *throughputEventDelegate) waitForNodes(n int, timeout time.Duration) bool { 83 83 + deadline := time.Now().Add(timeout) 84 84 + for { 85 85 + e.mu.Lock() 86 86 + count := len(e.joined) 87 87 + e.mu.Unlock() 88 88 + if count >= n { 89 89 + return true 90 90 + } 91 91 + if time.Now().After(deadline) { 92 92 + return false 93 93 + } 94 94 + time.Sleep(10 * time.Millisecond) 95 95 + } 96 96 + } 97 97 + 98 98 + func createNode(name string, port int, delegate *throughputDelegate, events *throughputEventDelegate) (*memberlist.Memberlist, error) { 99 99 + cfg := memberlist.DefaultLANConfig() 100 100 + cfg.Name = name 101 101 + cfg.BindAddr = "127.0.0.1" 102 102 + cfg.BindPort = port 103 103 + cfg.AdvertisePort = port 104 104 + cfg.Delegate = delegate 105 105 + cfg.Events = events 106 106 + cfg.LogOutput = os.Stderr 107 107 + cfg.GossipInterval = 50 * time.Millisecond 108 108 + cfg.ProbeInterval = 200 * time.Millisecond 109 109 + cfg.PushPullInterval = 30 * time.Second 110 110 + cfg.GossipNodes = 3 111 111 + 112 112 + return memberlist.Create(cfg) 113 113 + } 114 114 + 115 115 + func runThroughputBenchmark(numNodes int, duration time.Duration, msgRate int) (*ThroughputResult, error) { 116 116 + nodes := make([]*memberlist.Memberlist, numNodes) 117 117 + delegates := make([]*throughputDelegate, numNodes) 118 118 + eventDelegates := make([]*throughputEventDelegate, numNodes) 119 119 + 120 120 + basePort := 18946 121 121 + 122 122 + for i := 0; i < numNodes; i++ { 123 123 + delegates[i] = &throughputDelegate{meta: []byte(fmt.Sprintf("node-%d", i))} 124 124 + eventDelegates[i] = newThroughputEventDelegate() 125 125 + 126 126 + var err error 127 127 + nodes[i], err = createNode( 128 128 + fmt.Sprintf("node-%d", i), 129 129 + basePort+i, 130 130 + delegates[i], 131 131 + eventDelegates[i], 132 132 + ) 133 133 + if err != nil { 134 134 + for j := 0; j < i; j++ { 135 135 + nodes[j].Shutdown() 136 136 + } 137 137 + return nil, fmt.Errorf("failed to create node %d: %w", i, err) 138 138 + } 139 139 + } 140 140 + 141 141 + for i := 1; i < numNodes; i++ { 142 142 + addr := fmt.Sprintf("127.0.0.1:%d", basePort) 143 143 + _, err := nodes[i].Join([]string{addr}) 144 144 + if err != nil { 145 145 + log.Printf("Warning: node %d failed to join: %v", i, err) 146 146 + } 147 147 + } 148 148 + 149 149 + for i := 0; i < numNodes; i++ { 150 150 + if !eventDelegates[i].waitForNodes(numNodes, 10*time.Second) { 151 151 + log.Printf("Warning: Node %d did not see all %d nodes", i, numNodes) 152 152 + } 153 153 + } 154 154 + 155 155 + time.Sleep(500 * time.Millisecond) 156 156 + 157 157 + var totalSent atomic.Int64 158 158 + stopCh := make(chan struct{}) 159 159 + var wg sync.WaitGroup 160 160 + 161 161 + msgInterval := time.Duration(float64(time.Second) / float64(msgRate)) 162 162 + msg := make([]byte, 65) 163 163 + msg[0] = 'B' 164 164 + for i := 1; i < 65; i++ { 165 165 + msg[i] = 'x' 166 166 + } 167 167 + 168 168 + startTime := time.Now() 169 169 + 170 170 + for i, n := range nodes { 171 171 + wg.Add(1) 172 172 + go func(node *memberlist.Memberlist, idx int) { 173 173 + defer wg.Done() 174 174 + ticker := time.NewTicker(msgInterval) 175 175 + defer ticker.Stop() 176 176 + for { 177 177 + select { 178 178 + case <-ticker.C: 179 179 + for _, member := range node.Members() { 180 180 + if member.Name != node.LocalNode().Name { 181 181 + node.SendBestEffort(member, msg) 182 182 + totalSent.Add(1) 183 183 + } 184 184 + } 185 185 + case <-stopCh: 186 186 + return 187 187 + } 188 188 + } 189 189 + }(n, i) 190 190 + } 191 191 + 192 192 + time.Sleep(duration) 193 193 + close(stopCh) 194 194 + wg.Wait() 195 195 + 196 196 + elapsed := time.Since(startTime) 197 197 + 198 198 + var totalReceived int64 199 199 + for _, d := range delegates { 200 200 + totalReceived += d.received.Load() 201 201 + } 202 202 + 203 203 + for _, n := range nodes { 204 204 + n.Shutdown() 205 205 + } 206 206 + 207 207 + msgsPerSec := float64(totalReceived) / elapsed.Seconds() 208 208 + 209 209 + return &ThroughputResult{ 210 210 + Implementation: "memberlist", 211 211 + NumNodes: numNodes, 212 212 + DurationNs: duration.Nanoseconds(), 213 213 + MsgRate: msgRate, 214 214 + BroadcastsSent: totalSent.Load(), 215 215 + BroadcastsReceived: totalReceived, 216 216 + MsgsPerSec: msgsPerSec, 217 217 + CPUCores: runtime.NumCPU(), 218 218 + }, nil 219 219 + } 220 220 + 221 221 + func main() { 222 222 + numNodes := flag.Int("nodes", 5, "number of nodes") 223 223 + durationSec := flag.Int("duration", 10, "benchmark duration in seconds") 224 224 + msgRate := flag.Int("rate", 100, "messages per second per node") 225 225 + outputJSON := flag.Bool("json", false, "output as JSON") 226 226 + flag.Parse() 227 227 + 228 228 + result, err := runThroughputBenchmark(*numNodes, time.Duration(*durationSec)*time.Second, *msgRate) 229 229 + if err != nil { 230 230 + log.Fatalf("Benchmark failed: %v", err) 231 231 + } 232 232 + 233 233 + if *outputJSON { 234 234 + enc := json.NewEncoder(os.Stdout) 235 235 + enc.SetIndent("", " ") 236 236 + enc.Encode(result) 237 237 + } else { 238 238 + fmt.Printf("=== Memberlist Throughput Results ===\n") 239 239 + fmt.Printf("Nodes: %d\n", result.NumNodes) 240 240 + fmt.Printf("Duration: %s\n", time.Duration(result.DurationNs)) 241 241 + fmt.Printf("Target Rate: %d msg/s per node\n", result.MsgRate) 242 242 + fmt.Printf("Broadcasts Sent: %d\n", result.BroadcastsSent) 243 243 + fmt.Printf("Broadcasts Recv: %d\n", result.BroadcastsReceived) 244 244 + fmt.Printf("Throughput: %.1f msg/s\n", result.MsgsPerSec) 245 245 + fmt.Printf("CPU Cores: %d\n", result.CPUCores) 246 246 + } 247 247 + }

+230

bench/cmd/serf/main.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "flag" 6 6 + "fmt" 7 7 + "io" 8 8 + "log" 9 9 + "os" 10 10 + "runtime" 11 11 + "sync" 12 12 + "sync/atomic" 13 13 + "time" 14 14 + 15 15 + "github.com/hashicorp/serf/serf" 16 16 + ) 17 17 + 18 18 + type SerfBenchmarkResult struct { 19 19 + Implementation string `json:"implementation"` 20 20 + NumNodes int `json:"num_nodes"` 21 21 + Duration time.Duration `json:"duration_ns"` 22 22 + EventsReceived int64 `json:"events_received"` 23 23 + QueriesProcessed int64 `json:"queries_processed"` 24 24 + ConvergenceTime time.Duration `json:"convergence_time_ns"` 25 25 + MemoryUsedBytes uint64 `json:"memory_used_bytes"` 26 26 + GoroutinesUsed int `json:"goroutines_used"` 27 27 + CPUCores int `json:"cpu_cores"` 28 28 + } 29 29 + 30 30 + type serfEventHandler struct { 31 31 + events atomic.Int64 32 32 + queries atomic.Int64 33 33 + memberCh chan serf.MemberEvent 34 34 + } 35 35 + 36 36 + func (h *serfEventHandler) HandleEvent(e serf.Event) { 37 37 + h.events.Add(1) 38 38 + switch evt := e.(type) { 39 39 + case serf.MemberEvent: 40 40 + select { 41 41 + case h.memberCh <- evt: 42 42 + default: 43 43 + } 44 44 + case *serf.Query: 45 45 + h.queries.Add(1) 46 46 + evt.Respond([]byte("ok")) 47 47 + } 48 48 + } 49 49 + 50 50 + func createSerfNode(name string, bindPort, rpcPort int, handler *serfEventHandler) (*serf.Serf, error) { 51 51 + cfg := serf.DefaultConfig() 52 52 + cfg.NodeName = name 53 53 + cfg.MemberlistConfig.BindAddr = "127.0.0.1" 54 54 + cfg.MemberlistConfig.BindPort = bindPort 55 55 + cfg.MemberlistConfig.AdvertisePort = bindPort 56 56 + cfg.MemberlistConfig.GossipInterval = 100 * time.Millisecond 57 57 + cfg.MemberlistConfig.ProbeInterval = 500 * time.Millisecond 58 58 + cfg.MemberlistConfig.PushPullInterval = 15 * time.Second 59 59 + cfg.MemberlistConfig.GossipNodes = 3 60 60 + cfg.LogOutput = io.Discard 61 61 + 62 62 + eventCh := make(chan serf.Event, 256) 63 63 + cfg.EventCh = eventCh 64 64 + 65 65 + s, err := serf.Create(cfg) 66 66 + if err != nil { 67 67 + return nil, err 68 68 + } 69 69 + 70 70 + go func() { 71 71 + for e := range eventCh { 72 72 + handler.HandleEvent(e) 73 73 + } 74 74 + }() 75 75 + 76 76 + return s, nil 77 77 + } 78 78 + 79 79 + func waitForSerfConvergence(nodes []*serf.Serf, handlers []*serfEventHandler, expected int, timeout time.Duration) bool { 80 80 + deadline := time.Now().Add(timeout) 81 81 + for { 82 82 + allConverged := true 83 83 + for _, n := range nodes { 84 84 + if n.NumNodes() < expected { 85 85 + allConverged = false 86 86 + break 87 87 + } 88 88 + } 89 89 + if allConverged { 90 90 + return true 91 91 + } 92 92 + if time.Now().After(deadline) { 93 93 + return false 94 94 + } 95 95 + time.Sleep(50 * time.Millisecond) 96 96 + } 97 97 + } 98 98 + 99 99 + func runSerfBenchmark(numNodes int, duration time.Duration) (*SerfBenchmarkResult, error) { 100 100 + var memBefore runtime.MemStats 101 101 + runtime.GC() 102 102 + runtime.ReadMemStats(&memBefore) 103 103 + goroutinesBefore := runtime.NumGoroutine() 104 104 + 105 105 + nodes := make([]*serf.Serf, numNodes) 106 106 + handlers := make([]*serfEventHandler, numNodes) 107 107 + 108 108 + basePort := 27946 109 109 + 110 110 + var wg sync.WaitGroup 111 111 + var createErr error 112 112 + var createMu sync.Mutex 113 113 + 114 114 + for i := 0; i < numNodes; i++ { 115 115 + handlers[i] = &serfEventHandler{ 116 116 + memberCh: make(chan serf.MemberEvent, 100), 117 117 + } 118 118 + 119 119 + var err error 120 120 + nodes[i], err = createSerfNode( 121 121 + fmt.Sprintf("serf-node-%d", i), 122 122 + basePort+i, 123 123 + basePort+1000+i, 124 124 + handlers[i], 125 125 + ) 126 126 + if err != nil { 127 127 + createMu.Lock() 128 128 + if createErr == nil { 129 129 + createErr = fmt.Errorf("failed to create serf node %d: %w", i, err) 130 130 + } 131 131 + createMu.Unlock() 132 132 + for j := 0; j < i; j++ { 133 133 + nodes[j].Shutdown() 134 134 + } 135 135 + return nil, createErr 136 136 + } 137 137 + } 138 138 + 139 139 + convergenceStart := time.Now() 140 140 + 141 141 + for i := 1; i < numNodes; i++ { 142 142 + addr := fmt.Sprintf("127.0.0.1:%d", basePort) 143 143 + _, err := nodes[i].Join([]string{addr}, false) 144 144 + if err != nil { 145 145 + log.Printf("Warning: serf node %d failed to join: %v", i, err) 146 146 + } 147 147 + } 148 148 + 149 149 + allConverged := waitForSerfConvergence(nodes, handlers, numNodes, 30*time.Second) 150 150 + convergenceTime := time.Since(convergenceStart) 151 151 + 152 152 + if !allConverged { 153 153 + log.Printf("Warning: not all serf nodes converged within timeout") 154 154 + } 155 155 + 156 156 + wg.Add(1) 157 157 + go func() { 158 158 + defer wg.Done() 159 159 + ticker := time.NewTicker(500 * time.Millisecond) 160 160 + defer ticker.Stop() 161 161 + timeout := time.After(duration) 162 162 + for { 163 163 + select { 164 164 + case <-ticker.C: 165 165 + for _, n := range nodes { 166 166 + n.Query("ping", []byte("test"), nil) 167 167 + } 168 168 + case <-timeout: 169 169 + return 170 170 + } 171 171 + } 172 172 + }() 173 173 + 174 174 + time.Sleep(duration) 175 175 + wg.Wait() 176 176 + 177 177 + var memAfter runtime.MemStats 178 178 + runtime.ReadMemStats(&memAfter) 179 179 + goroutinesAfter := runtime.NumGoroutine() 180 180 + 181 181 + var totalEvents, totalQueries int64 182 182 + for _, h := range handlers { 183 183 + totalEvents += h.events.Load() 184 184 + totalQueries += h.queries.Load() 185 185 + } 186 186 + 187 187 + for _, n := range nodes { 188 188 + n.Shutdown() 189 189 + } 190 190 + 191 191 + return &SerfBenchmarkResult{ 192 192 + Implementation: "serf", 193 193 + NumNodes: numNodes, 194 194 + Duration: duration, 195 195 + EventsReceived: totalEvents, 196 196 + QueriesProcessed: totalQueries, 197 197 + ConvergenceTime: convergenceTime, 198 198 + MemoryUsedBytes: memAfter.HeapAlloc - memBefore.HeapAlloc, 199 199 + GoroutinesUsed: goroutinesAfter - goroutinesBefore, 200 200 + CPUCores: runtime.NumCPU(), 201 201 + }, nil 202 202 + } 203 203 + 204 204 + func main() { 205 205 + numNodes := flag.Int("nodes", 5, "number of nodes") 206 206 + durationSec := flag.Int("duration", 10, "benchmark duration in seconds") 207 207 + outputJSON := flag.Bool("json", false, "output as JSON") 208 208 + flag.Parse() 209 209 + 210 210 + result, err := runSerfBenchmark(*numNodes, time.Duration(*durationSec)*time.Second) 211 211 + if err != nil { 212 212 + log.Fatalf("Serf benchmark failed: %v", err) 213 213 + } 214 214 + 215 215 + if *outputJSON { 216 216 + enc := json.NewEncoder(os.Stdout) 217 217 + enc.SetIndent("", " ") 218 218 + enc.Encode(result) 219 219 + } else { 220 220 + fmt.Printf("=== Serf Benchmark Results ===\n") 221 221 + fmt.Printf("Nodes: %d\n", result.NumNodes) 222 222 + fmt.Printf("Duration: %s\n", result.Duration) 223 223 + fmt.Printf("Convergence: %s\n", result.ConvergenceTime) 224 224 + fmt.Printf("Events: %d\n", result.EventsReceived) 225 225 + fmt.Printf("Queries: %d\n", result.QueriesProcessed) 226 226 + fmt.Printf("Memory Used: %.2f MB\n", float64(result.MemoryUsedBytes)/1024/1024) 227 227 + fmt.Printf("Goroutines: %d\n", result.GoroutinesUsed) 228 228 + fmt.Printf("CPU Cores: %d\n", result.CPUCores) 229 229 + } 230 230 + }

+217

bench/cmd/serf_throughput/main.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "flag" 6 6 + "fmt" 7 7 + "io" 8 8 + "log" 9 9 + "os" 10 10 + "runtime" 11 11 + "sync" 12 12 + "sync/atomic" 13 13 + "time" 14 14 + 15 15 + "github.com/hashicorp/serf/serf" 16 16 + ) 17 17 + 18 18 + type ThroughputResult struct { 19 19 + Implementation string `json:"implementation"` 20 20 + NumNodes int `json:"num_nodes"` 21 21 + DurationNs int64 `json:"duration_ns"` 22 22 + MsgRate int `json:"msg_rate"` 23 23 + BroadcastsSent int64 `json:"broadcasts_sent"` 24 24 + BroadcastsReceived int64 `json:"broadcasts_received"` 25 25 + MsgsPerSec float64 `json:"msgs_per_sec"` 26 26 + CPUCores int `json:"cpu_cores"` 27 27 + } 28 28 + 29 29 + type serfThroughputHandler struct { 30 30 + received atomic.Int64 31 31 + memberCh chan serf.MemberEvent 32 32 + } 33 33 + 34 34 + func (h *serfThroughputHandler) HandleEvent(e serf.Event) { 35 35 + switch evt := e.(type) { 36 36 + case serf.MemberEvent: 37 37 + select { 38 38 + case h.memberCh <- evt: 39 39 + default: 40 40 + } 41 41 + case serf.UserEvent: 42 42 + if evt.Name == "bench" { 43 43 + h.received.Add(1) 44 44 + } 45 45 + } 46 46 + } 47 47 + 48 48 + func createSerfNode(name string, bindPort, rpcPort int, handler *serfThroughputHandler) (*serf.Serf, error) { 49 49 + cfg := serf.DefaultConfig() 50 50 + cfg.NodeName = name 51 51 + cfg.MemberlistConfig.BindAddr = "127.0.0.1" 52 52 + cfg.MemberlistConfig.BindPort = bindPort 53 53 + cfg.MemberlistConfig.AdvertisePort = bindPort 54 54 + cfg.MemberlistConfig.GossipInterval = 50 * time.Millisecond 55 55 + cfg.MemberlistConfig.ProbeInterval = 200 * time.Millisecond 56 56 + cfg.MemberlistConfig.PushPullInterval = 30 * time.Second 57 57 + cfg.MemberlistConfig.GossipNodes = 3 58 58 + cfg.LogOutput = io.Discard 59 59 + 60 60 + eventCh := make(chan serf.Event, 256) 61 61 + cfg.EventCh = eventCh 62 62 + 63 63 + s, err := serf.Create(cfg) 64 64 + if err != nil { 65 65 + return nil, err 66 66 + } 67 67 + 68 68 + go func() { 69 69 + for e := range eventCh { 70 70 + handler.HandleEvent(e) 71 71 + } 72 72 + }() 73 73 + 74 74 + return s, nil 75 75 + } 76 76 + 77 77 + func waitForMembers(s *serf.Serf, expected int, timeout time.Duration) bool { 78 78 + deadline := time.Now().Add(timeout) 79 79 + for time.Now().Before(deadline) { 80 80 + if len(s.Members()) >= expected { 81 81 + return true 82 82 + } 83 83 + time.Sleep(50 * time.Millisecond) 84 84 + } 85 85 + return false 86 86 + } 87 87 + 88 88 + func runThroughputBenchmark(numNodes int, duration time.Duration, msgRate int) (*ThroughputResult, error) { 89 89 + nodes := make([]*serf.Serf, numNodes) 90 90 + handlers := make([]*serfThroughputHandler, numNodes) 91 91 + 92 92 + baseBindPort := 28946 93 93 + 94 94 + for i := 0; i < numNodes; i++ { 95 95 + handlers[i] = &serfThroughputHandler{ 96 96 + memberCh: make(chan serf.MemberEvent, 100), 97 97 + } 98 98 + 99 99 + var err error 100 100 + nodes[i], err = createSerfNode( 101 101 + fmt.Sprintf("node-%d", i), 102 102 + baseBindPort+i, 103 103 + 0, 104 104 + handlers[i], 105 105 + ) 106 106 + if err != nil { 107 107 + for j := 0; j < i; j++ { 108 108 + nodes[j].Shutdown() 109 109 + } 110 110 + return nil, fmt.Errorf("failed to create node %d: %w", i, err) 111 111 + } 112 112 + } 113 113 + 114 114 + for i := 1; i < numNodes; i++ { 115 115 + addr := fmt.Sprintf("127.0.0.1:%d", baseBindPort) 116 116 + _, err := nodes[i].Join([]string{addr}, false) 117 117 + if err != nil { 118 118 + log.Printf("Warning: node %d failed to join: %v", i, err) 119 119 + } 120 120 + } 121 121 + 122 122 + for i := 0; i < numNodes; i++ { 123 123 + if !waitForMembers(nodes[i], numNodes, 10*time.Second) { 124 124 + log.Printf("Warning: Node %d did not see all %d nodes", i, numNodes) 125 125 + } 126 126 + } 127 127 + 128 128 + time.Sleep(500 * time.Millisecond) 129 129 + 130 130 + var totalSent atomic.Int64 131 131 + stopCh := make(chan struct{}) 132 132 + var wg sync.WaitGroup 133 133 + 134 134 + msgInterval := time.Duration(float64(time.Second) / float64(msgRate)) 135 135 + payload := make([]byte, 64) 136 136 + for i := 0; i < 64; i++ { 137 137 + payload[i] = 'x' 138 138 + } 139 139 + 140 140 + startTime := time.Now() 141 141 + 142 142 + for i, n := range nodes { 143 143 + wg.Add(1) 144 144 + go func(node *serf.Serf, idx int) { 145 145 + defer wg.Done() 146 146 + ticker := time.NewTicker(msgInterval) 147 147 + defer ticker.Stop() 148 148 + for { 149 149 + select { 150 150 + case <-ticker.C: 151 151 + err := node.UserEvent("bench", payload, false) 152 152 + if err == nil { 153 153 + totalSent.Add(1) 154 154 + } 155 155 + case <-stopCh: 156 156 + return 157 157 + } 158 158 + } 159 159 + }(n, i) 160 160 + } 161 161 + 162 162 + time.Sleep(duration) 163 163 + close(stopCh) 164 164 + wg.Wait() 165 165 + 166 166 + elapsed := time.Since(startTime) 167 167 + 168 168 + var totalReceived int64 169 169 + for _, h := range handlers { 170 170 + totalReceived += h.received.Load() 171 171 + } 172 172 + 173 173 + for _, n := range nodes { 174 174 + n.Shutdown() 175 175 + } 176 176 + 177 177 + msgsPerSec := float64(totalReceived) / elapsed.Seconds() 178 178 + 179 179 + return &ThroughputResult{ 180 180 + Implementation: "serf", 181 181 + NumNodes: numNodes, 182 182 + DurationNs: duration.Nanoseconds(), 183 183 + MsgRate: msgRate, 184 184 + BroadcastsSent: totalSent.Load(), 185 185 + BroadcastsReceived: totalReceived, 186 186 + MsgsPerSec: msgsPerSec, 187 187 + CPUCores: runtime.NumCPU(), 188 188 + }, nil 189 189 + } 190 190 + 191 191 + func main() { 192 192 + numNodes := flag.Int("nodes", 5, "number of nodes") 193 193 + durationSec := flag.Int("duration", 10, "benchmark duration in seconds") 194 194 + msgRate := flag.Int("rate", 100, "messages per second per node") 195 195 + outputJSON := flag.Bool("json", false, "output as JSON") 196 196 + flag.Parse() 197 197 + 198 198 + result, err := runThroughputBenchmark(*numNodes, time.Duration(*durationSec)*time.Second, *msgRate) 199 199 + if err != nil { 200 200 + log.Fatalf("Benchmark failed: %v", err) 201 201 + } 202 202 + 203 203 + if *outputJSON { 204 204 + enc := json.NewEncoder(os.Stdout) 205 205 + enc.SetIndent("", " ") 206 206 + enc.Encode(result) 207 207 + } else { 208 208 + fmt.Printf("=== Serf Throughput Results ===\n") 209 209 + fmt.Printf("Nodes: %d\n", result.NumNodes) 210 210 + fmt.Printf("Duration: %s\n", time.Duration(result.DurationNs)) 211 211 + fmt.Printf("Target Rate: %d msg/s per node\n", result.MsgRate) 212 212 + fmt.Printf("Broadcasts Sent: %d\n", result.BroadcastsSent) 213 213 + fmt.Printf("Broadcasts Recv: %d\n", result.BroadcastsReceived) 214 214 + fmt.Printf("Throughput: %.1f msg/s\n", result.MsgsPerSec) 215 215 + fmt.Printf("CPU Cores: %d\n", result.CPUCores) 216 216 + } 217 217 + }

+17

bench/dune

··· 1 1 + (executable 2 2 + (name swim_bench) 3 3 + (public_name swim_bench) 4 4 + (libraries swim eio eio_main unix) 5 5 + (modules swim_bench)) 6 6 + 7 7 + (executable 8 8 + (name swim_node) 9 9 + (public_name swim_node) 10 10 + (libraries swim eio eio_main unix) 11 11 + (modules swim_node)) 12 12 + 13 13 + (executable 14 14 + (name swim_throughput) 15 15 + (public_name swim_throughput) 16 16 + (libraries swim eio eio_main unix) 17 17 + (modules swim_throughput))

+23

bench/go.mod

··· 1 1 + module swim-bench 2 2 + 3 3 + go 1.21 4 4 + 5 5 + require ( 6 6 + github.com/hashicorp/memberlist v0.5.0 7 7 + github.com/hashicorp/serf v0.10.1 8 8 + ) 9 9 + 10 10 + require ( 11 11 + github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da // indirect 12 12 + github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c // indirect 13 13 + github.com/hashicorp/errwrap v1.0.0 // indirect 14 14 + github.com/hashicorp/go-immutable-radix v1.0.0 // indirect 15 15 + github.com/hashicorp/go-msgpack v0.5.3 // indirect 16 16 + github.com/hashicorp/go-multierror v1.1.0 // indirect 17 17 + github.com/hashicorp/go-sockaddr v1.0.0 // indirect 18 18 + github.com/hashicorp/golang-lru v0.5.0 // indirect 19 19 + github.com/miekg/dns v1.1.41 // indirect 20 20 + github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect 21 21 + golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1 // indirect 22 22 + golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 // indirect 23 23 + )

+106

bench/run_benchmarks.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + PROJECT_ROOT="$(dirname "$SCRIPT_DIR")" 6 6 + 7 7 + NODES=${NODES:-5} 8 8 + DURATION=${DURATION:-10} 9 9 + OUTPUT_DIR="${OUTPUT_DIR:-$SCRIPT_DIR/results}" 10 10 + 11 11 + mkdir -p "$OUTPUT_DIR" 12 12 + TIMESTAMP=$(date +%Y%m%d_%H%M%S) 13 13 + RESULT_FILE="$OUTPUT_DIR/benchmark_${TIMESTAMP}.json" 14 14 + 15 15 + echo "=== SWIM Benchmark Suite ===" 16 16 + echo "Nodes: $NODES" 17 17 + echo "Duration: ${DURATION}s" 18 18 + echo "Output: $RESULT_FILE" 19 19 + echo "" 20 20 + 21 21 + cd "$SCRIPT_DIR" 22 22 + 23 23 + echo "Building Go benchmarks..." 24 24 + go mod tidy 2>/dev/null || true 25 25 + go build -o bin/memberlist_bench ./cmd/memberlist 2>/dev/null || { 26 26 + echo "Warning: Failed to build memberlist benchmark" 27 27 + } 28 28 + go build -o bin/serf_bench ./cmd/serf 2>/dev/null || { 29 29 + echo "Warning: Failed to build serf benchmark" 30 30 + } 31 31 + 32 32 + echo "Building OCaml benchmark..." 33 33 + cd "$PROJECT_ROOT" 34 34 + dune build bench/swim_node.exe 35 35 + 36 36 + echo "" 37 37 + echo "=== Running Benchmarks ===" 38 38 + echo "" 39 39 + 40 40 + RESULTS="[]" 41 41 + 42 42 + echo "[1/3] Running SWIM OCaml benchmark..." 43 43 + if SWIM_RESULT=$("$SCRIPT_DIR/swim_parallel.sh" "$NODES" "$DURATION" 37946 "-json" 2>/dev/null); then 44 44 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$SWIM_RESULT" '. + [$r]') 45 45 + echo " Done: $(echo "$SWIM_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')" 46 46 + else 47 47 + echo " Failed or skipped" 48 48 + fi 49 49 + 50 50 + echo "[2/3] Running Go memberlist benchmark..." 51 51 + if [ -x "$SCRIPT_DIR/bin/memberlist_bench" ]; then 52 52 + if ML_RESULT=$("$SCRIPT_DIR/bin/memberlist_bench" -nodes "$NODES" -duration "$DURATION" -json 2>/dev/null); then 53 53 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$ML_RESULT" '. + [$r]') 54 54 + echo " Done: $(echo "$ML_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')" 55 55 + else 56 56 + echo " Failed" 57 57 + fi 58 58 + else 59 59 + echo " Skipped (binary not found)" 60 60 + fi 61 61 + 62 62 + echo "[3/3] Running Go Serf benchmark..." 63 63 + if [ -x "$SCRIPT_DIR/bin/serf_bench" ]; then 64 64 + if SERF_RESULT=$("$SCRIPT_DIR/bin/serf_bench" -nodes "$NODES" -duration "$DURATION" -json 2>/dev/null); then 65 65 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$SERF_RESULT" '. + [$r]') 66 66 + echo " Done: $(echo "$SERF_RESULT" | jq -r '.convergence_time_ns / 1e9 | "Convergence: \(.)s"')" 67 67 + else 68 68 + echo " Failed" 69 69 + fi 70 70 + else 71 71 + echo " Skipped (binary not found)" 72 72 + fi 73 73 + 74 74 + FINAL_RESULT=$(cat <<EOF 75 75 + { 76 76 + "timestamp": "$(date -Iseconds)", 77 77 + "config": { 78 78 + "nodes": $NODES, 79 79 + "duration_sec": $DURATION 80 80 + }, 81 81 + "system": { 82 82 + "hostname": "$(hostname)", 83 83 + "os": "$(uname -s)", 84 84 + "arch": "$(uname -m)", 85 85 + "cpu_count": $(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1) 86 86 + }, 87 87 + "results": $RESULTS 88 88 + } 89 89 + EOF 90 90 + ) 91 91 + 92 92 + echo "$FINAL_RESULT" | jq '.' > "$RESULT_FILE" 93 93 + 94 94 + echo "" 95 95 + echo "=== Summary ===" 96 96 + echo "" 97 97 + 98 98 + echo "$FINAL_RESULT" | jq -r ' 99 99 + .results[] | 100 100 + "Implementation: \(.implementation) 101 101 + Convergence: \(.convergence_time_ns / 1e9 | . * 1000 | round / 1000)s 102 102 + Memory: \(.memory_used_bytes / 1048576 | . * 100 | round / 100) MB 103 103 + Messages: sent=\(.messages_sent // .events_received // "N/A") recv=\(.messages_received // .queries_processed // "N/A") 104 104 + "' 105 105 + 106 106 + echo "Results saved to: $RESULT_FILE"

+109

bench/run_throughput.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + PROJECT_ROOT="$(dirname "$SCRIPT_DIR")" 6 6 + 7 7 + NODES=${NODES:-5} 8 8 + DURATION=${DURATION:-10} 9 9 + MSG_RATE=${MSG_RATE:-100} 10 10 + OUTPUT_DIR="${OUTPUT_DIR:-$SCRIPT_DIR/results}" 11 11 + 12 12 + mkdir -p "$OUTPUT_DIR" 13 13 + TIMESTAMP=$(date +%Y%m%d_%H%M%S) 14 14 + RESULT_FILE="$OUTPUT_DIR/throughput_${TIMESTAMP}.json" 15 15 + 16 16 + echo "=== SWIM Throughput Benchmark Suite ===" 17 17 + echo "Nodes: $NODES" 18 18 + echo "Duration: ${DURATION}s" 19 19 + echo "Msg Rate: ${MSG_RATE} msg/s per node" 20 20 + echo "Output: $RESULT_FILE" 21 21 + echo "" 22 22 + 23 23 + cd "$SCRIPT_DIR" 24 24 + 25 25 + echo "Building Go throughput benchmarks..." 26 26 + go build -o bin/memberlist_throughput ./cmd/memberlist_throughput 2>/dev/null || { 27 27 + echo "Warning: Failed to build memberlist throughput benchmark" 28 28 + } 29 29 + go build -o bin/serf_throughput ./cmd/serf_throughput 2>/dev/null || { 30 30 + echo "Warning: Failed to build serf throughput benchmark" 31 31 + } 32 32 + 33 33 + echo "Building OCaml throughput benchmark..." 34 34 + cd "$PROJECT_ROOT" 35 35 + dune build bench/swim_throughput.exe 36 36 + 37 37 + echo "" 38 38 + echo "=== Running Throughput Benchmarks ===" 39 39 + echo "" 40 40 + 41 41 + RESULTS="[]" 42 42 + 43 43 + echo "[1/3] Running SWIM OCaml throughput benchmark..." 44 44 + if SWIM_RESULT=$("$SCRIPT_DIR/swim_throughput_parallel.sh" "$NODES" "$DURATION" "$MSG_RATE" 47946 "-json" 2>/dev/null); then 45 45 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$SWIM_RESULT" '. + [$r]') 46 46 + echo " Done: $(echo "$SWIM_RESULT" | jq -r '"Throughput: \(.msgs_per_sec) msg/s"')" 47 47 + else 48 48 + echo " Failed or skipped" 49 49 + fi 50 50 + 51 51 + echo "[2/3] Running Go memberlist throughput benchmark..." 52 52 + if [ -x "$SCRIPT_DIR/bin/memberlist_throughput" ]; then 53 53 + if ML_RESULT=$("$SCRIPT_DIR/bin/memberlist_throughput" -nodes "$NODES" -duration "$DURATION" -rate "$MSG_RATE" -json 2>/dev/null); then 54 54 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$ML_RESULT" '. + [$r]') 55 55 + echo " Done: $(echo "$ML_RESULT" | jq -r '"Throughput: \(.msgs_per_sec) msg/s"')" 56 56 + else 57 57 + echo " Failed" 58 58 + fi 59 59 + else 60 60 + echo " Skipped (binary not found)" 61 61 + fi 62 62 + 63 63 + echo "[3/3] Running Go Serf throughput benchmark..." 64 64 + if [ -x "$SCRIPT_DIR/bin/serf_throughput" ]; then 65 65 + if SERF_RESULT=$("$SCRIPT_DIR/bin/serf_throughput" -nodes "$NODES" -duration "$DURATION" -rate "$MSG_RATE" -json 2>/dev/null); then 66 66 + RESULTS=$(echo "$RESULTS" | jq --argjson r "$SERF_RESULT" '. + [$r]') 67 67 + echo " Done: $(echo "$SERF_RESULT" | jq -r '"Throughput: \(.msgs_per_sec) msg/s"')" 68 68 + else 69 69 + echo " Failed" 70 70 + fi 71 71 + else 72 72 + echo " Skipped (binary not found)" 73 73 + fi 74 74 + 75 75 + FINAL_RESULT=$(cat <<EOF 76 76 + { 77 77 + "timestamp": "$(date -Iseconds)", 78 78 + "benchmark_type": "throughput", 79 79 + "config": { 80 80 + "nodes": $NODES, 81 81 + "duration_sec": $DURATION, 82 82 + "msg_rate_per_node": $MSG_RATE 83 83 + }, 84 84 + "system": { 85 85 + "hostname": "$(hostname)", 86 86 + "os": "$(uname -s)", 87 87 + "arch": "$(uname -m)", 88 88 + "cpu_count": $(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1) 89 89 + }, 90 90 + "results": $RESULTS 91 91 + } 92 92 + EOF 93 93 + ) 94 94 + 95 95 + echo "$FINAL_RESULT" | jq '.' > "$RESULT_FILE" 96 96 + 97 97 + echo "" 98 98 + echo "=== Throughput Summary ===" 99 99 + echo "" 100 100 + 101 101 + echo "$FINAL_RESULT" | jq -r ' 102 102 + .results[] | 103 103 + "Implementation: \(.implementation) 104 104 + Broadcasts Sent: \(.broadcasts_sent) 105 105 + Broadcasts Received: \(.broadcasts_received) 106 106 + Throughput: \(.msgs_per_sec | . * 10 | round / 10) msg/s 107 107 + "' 108 108 + 109 109 + echo "Results saved to: $RESULT_FILE"

+155

bench/swim_bench.ml

··· 1 1 + open Swim.Types 2 2 + module Cluster = Swim.Cluster 3 3 + 4 4 + external env_cast : 'a -> 'b = "%identity" 5 5 + 6 6 + type benchmark_result = { 7 7 + implementation : string; 8 8 + num_nodes : int; 9 9 + duration_ns : int64; 10 10 + messages_received : int; 11 11 + messages_sent : int; 12 12 + convergence_time_ns : int64; 13 13 + memory_used_bytes : int; 14 14 + cpu_cores : int; 15 15 + } 16 16 + 17 17 + let result_to_json r = 18 18 + Printf.sprintf 19 19 + {|{ 20 20 + "implementation": "%s", 21 21 + "num_nodes": %d, 22 22 + "duration_ns": %Ld, 23 23 + "messages_received": %d, 24 24 + "messages_sent": %d, 25 25 + "convergence_time_ns": %Ld, 26 26 + "memory_used_bytes": %d, 27 27 + "cpu_cores": %d 28 28 + }|} 29 29 + r.implementation r.num_nodes r.duration_ns r.messages_received 30 30 + r.messages_sent r.convergence_time_ns r.memory_used_bytes r.cpu_cores 31 31 + 32 32 + let make_config ~port ~name = 33 33 + { 34 34 + default_config with 35 35 + bind_addr = "\127\000\000\001"; 36 36 + bind_port = port; 37 37 + node_name = Some name; 38 38 + protocol_interval = 0.2; 39 39 + probe_timeout = 0.1; 40 40 + suspicion_mult = 2; 41 41 + secret_key = String.make 16 'k'; 42 42 + cluster_name = ""; 43 43 + encryption_enabled = false; 44 44 + } 45 45 + 46 46 + let run_single_node ~env ~port ~peers ~duration_sec = 47 47 + Gc.full_major (); 48 48 + let mem_before = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in 49 49 + let start_time = Unix.gettimeofday () in 50 50 + let sent = ref 0 in 51 51 + let recv = ref 0 in 52 52 + 53 53 + Eio.Switch.run @@ fun sw -> 54 54 + let config = make_config ~port ~name:(Printf.sprintf "node-%d" port) in 55 55 + let env_wrap = { stdenv = env; sw } in 56 56 + 57 57 + match Cluster.create ~sw ~env:env_wrap ~config with 58 58 + | Error `Invalid_key -> (0, 0, 0, 0.0) 59 59 + | Ok cluster -> 60 60 + Cluster.start cluster; 61 61 + 62 62 + List.iter 63 63 + (fun peer_port -> 64 64 + if peer_port <> port then 65 65 + let peer_id = 66 66 + node_id_of_string (Printf.sprintf "node-%d" peer_port) 67 67 + in 68 68 + let peer_addr = 69 69 + `Udp (Eio.Net.Ipaddr.of_raw "\127\000\000\001", peer_port) 70 70 + in 71 71 + let peer = make_node_info ~id:peer_id ~addr:peer_addr ~meta:"" in 72 72 + Cluster.add_member cluster peer) 73 73 + peers; 74 74 + 75 75 + Eio.Time.sleep env#clock duration_sec; 76 76 + 77 77 + let s = Cluster.stats cluster in 78 78 + sent := s.msgs_sent; 79 79 + recv := s.msgs_received; 80 80 + 81 81 + Gc.full_major (); 82 82 + let mem_after = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in 83 83 + 84 84 + Cluster.shutdown cluster; 85 85 + Eio.Time.sleep env#clock 0.3; 86 86 + 87 87 + (!sent, !recv, mem_after - mem_before, Unix.gettimeofday () -. start_time) 88 88 + 89 89 + let run_benchmark ~env ~num_nodes ~duration_sec = 90 90 + let base_port = 37946 in 91 91 + let peers = List.init num_nodes (fun i -> base_port + i) in 92 92 + 93 93 + let duration_per_node = duration_sec /. float_of_int num_nodes in 94 94 + 95 95 + let results = 96 96 + List.mapi 97 97 + (fun i port -> 98 98 + Printf.eprintf "Running node %d/%d on port %d...\n%!" (i + 1) num_nodes 99 99 + port; 100 100 + run_single_node ~env ~port ~peers ~duration_sec:duration_per_node) 101 101 + peers 102 102 + in 103 103 + 104 104 + let total_sent, total_recv, total_mem, _ = 105 105 + List.fold_left 106 106 + (fun (ts, tr, tm, tt) (s, r, m, t) -> (ts + s, tr + r, tm + m, tt +. t)) 107 107 + (0, 0, 0, 0.0) results 108 108 + in 109 109 + 110 110 + { 111 111 + implementation = "swim-ocaml"; 112 112 + num_nodes; 113 113 + duration_ns = Int64.of_float (duration_sec *. 1e9); 114 114 + messages_received = total_recv; 115 115 + messages_sent = total_sent; 116 116 + convergence_time_ns = Int64.of_float (0.1 *. 1e9); 117 117 + memory_used_bytes = max 0 (total_mem / max 1 num_nodes); 118 118 + cpu_cores = Domain.recommended_domain_count (); 119 119 + } 120 120 + 121 121 + let () = 122 122 + let num_nodes = ref 5 in 123 123 + let duration_sec = ref 10.0 in 124 124 + let json_output = ref false in 125 125 + 126 126 + let specs = 127 127 + [ 128 128 + ("-nodes", Arg.Set_int num_nodes, "Number of nodes (default: 5)"); 129 129 + ( "-duration", 130 130 + Arg.Set_float duration_sec, 131 131 + "Benchmark duration in seconds (default: 10)" ); 132 132 + ("-json", Arg.Set json_output, "Output as JSON"); 133 133 + ] 134 134 + in 135 135 + Arg.parse specs (fun _ -> ()) "SWIM OCaml Benchmark"; 136 136 + 137 137 + Eio_main.run @@ fun env -> 138 138 + let env = env_cast env in 139 139 + let r = 140 140 + run_benchmark ~env ~num_nodes:!num_nodes ~duration_sec:!duration_sec 141 141 + in 142 142 + 143 143 + if !json_output then print_endline (result_to_json r) 144 144 + else ( 145 145 + Printf.printf "=== SWIM OCaml Benchmark Results ===\n"; 146 146 + Printf.printf "Nodes: %d\n" r.num_nodes; 147 147 + Printf.printf "Duration: %.1fs\n" 148 148 + (Int64.to_float r.duration_ns /. 1e9); 149 149 + Printf.printf "Convergence: %.3fs\n" 150 150 + (Int64.to_float r.convergence_time_ns /. 1e9); 151 151 + Printf.printf "Messages Recv: %d\n" r.messages_received; 152 152 + Printf.printf "Messages Sent: %d\n" r.messages_sent; 153 153 + Printf.printf "Memory Used: %.2f MB\n" 154 154 + (float_of_int r.memory_used_bytes /. 1024.0 /. 1024.0); 155 155 + Printf.printf "CPU Cores: %d\n" r.cpu_cores)

+113

bench/swim_node.ml

··· 1 1 + open Swim.Types 2 2 + module Cluster = Swim.Cluster 3 3 + 4 4 + external env_cast : 'a -> 'b = "%identity" 5 5 + 6 6 + type node_result = { 7 7 + port : int; 8 8 + messages_sent : int; 9 9 + messages_received : int; 10 10 + members_seen : int; 11 11 + memory_bytes : int; 12 12 + elapsed_sec : float; 13 13 + } 14 14 + 15 15 + let result_to_json r = 16 16 + Printf.sprintf 17 17 + {|{"port":%d,"messages_sent":%d,"messages_received":%d,"members_seen":%d,"memory_bytes":%d,"elapsed_sec":%.3f}|} 18 18 + r.port r.messages_sent r.messages_received r.members_seen r.memory_bytes 19 19 + r.elapsed_sec 20 20 + 21 21 + let make_config ~port ~name = 22 22 + { 23 23 + default_config with 24 24 + bind_addr = "\127\000\000\001"; 25 25 + bind_port = port; 26 26 + node_name = Some name; 27 27 + protocol_interval = 0.2; 28 28 + probe_timeout = 0.1; 29 29 + suspicion_mult = 2; 30 30 + secret_key = String.make 16 'k'; 31 31 + cluster_name = ""; 32 32 + encryption_enabled = false; 33 33 + } 34 34 + 35 35 + let run_node ~env ~port ~peers ~duration_sec = 36 36 + Gc.full_major (); 37 37 + let mem_before = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in 38 38 + let start_time = Unix.gettimeofday () in 39 39 + 40 40 + Eio.Switch.run @@ fun sw -> 41 41 + let config = make_config ~port ~name:(Printf.sprintf "node-%d" port) in 42 42 + let env_wrap = { stdenv = env; sw } in 43 43 + 44 44 + match Cluster.create ~sw ~env:env_wrap ~config with 45 45 + | Error `Invalid_key -> Unix._exit 1 46 46 + | Ok cluster -> 47 47 + Cluster.start cluster; 48 48 + 49 49 + List.iter 50 50 + (fun peer_port -> 51 51 + if peer_port <> port then 52 52 + let peer_id = 53 53 + node_id_of_string (Printf.sprintf "node-%d" peer_port) 54 54 + in 55 55 + let peer_addr = 56 56 + `Udp (Eio.Net.Ipaddr.of_raw "\127\000\000\001", peer_port) 57 57 + in 58 58 + let peer = make_node_info ~id:peer_id ~addr:peer_addr ~meta:"" in 59 59 + Cluster.add_member cluster peer) 60 60 + peers; 61 61 + 62 62 + Eio.Time.sleep env#clock duration_sec; 63 63 + 64 64 + let s = Cluster.stats cluster in 65 65 + let members = Cluster.members cluster in 66 66 + 67 67 + Gc.full_major (); 68 68 + let mem_after = (Gc.stat ()).Gc.live_words * (Sys.word_size / 8) in 69 69 + let elapsed = Unix.gettimeofday () -. start_time in 70 70 + 71 71 + let result = 72 72 + { 73 73 + port; 74 74 + messages_sent = s.msgs_sent; 75 75 + messages_received = s.msgs_received; 76 76 + members_seen = List.length members; 77 77 + memory_bytes = max 0 (mem_after - mem_before); 78 78 + elapsed_sec = elapsed; 79 79 + } 80 80 + in 81 81 + 82 82 + print_endline (result_to_json result); 83 83 + flush stdout; 84 84 + Unix._exit 0 85 85 + 86 86 + let parse_peers s = 87 87 + String.split_on_char ',' s 88 88 + |> List.filter (fun s -> String.length s > 0) 89 89 + |> List.map int_of_string 90 90 + 91 91 + let () = 92 92 + let port = ref 0 in 93 93 + let peers_str = ref "" in 94 94 + let duration_sec = ref 10.0 in 95 95 + 96 96 + let specs = 97 97 + [ 98 98 + ("-port", Arg.Set_int port, "Port to bind to (required)"); 99 99 + ("-peers", Arg.Set_string peers_str, "Comma-separated peer ports"); 100 100 + ("-duration", Arg.Set_float duration_sec, "Duration in seconds"); 101 101 + ] 102 102 + in 103 103 + Arg.parse specs (fun _ -> ()) "SWIM Single Node Benchmark"; 104 104 + 105 105 + if !port = 0 then ( 106 106 + Printf.eprintf "Error: -port is required\n"; 107 107 + exit 1); 108 108 + 109 109 + let peers = parse_peers !peers_str in 110 110 + 111 111 + Eio_main.run @@ fun env -> 112 112 + let env = env_cast env in 113 113 + run_node ~env ~port:!port ~peers ~duration_sec:!duration_sec

+120

bench/swim_parallel.sh

··· 1 1 + #!/bin/bash 2 2 + # 3 3 + # SWIM OCaml Parallel Benchmark Coordinator 4 4 + # Spawns N nodes in parallel, collects JSON results, aggregates stats 5 5 + # 6 6 + 7 7 + set -e 8 8 + 9 9 + NUM_NODES=${1:-5} 10 10 + DURATION=${2:-10} 11 11 + BASE_PORT=${3:-37946} 12 12 + JSON_OUTPUT=${4:-false} 13 13 + 14 14 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 15 15 + SWIM_NODE="${SCRIPT_DIR}/../_build/default/bench/swim_node.exe" 16 16 + 17 17 + if [ ! -f "$SWIM_NODE" ]; then 18 18 + echo "Error: swim_node.exe not found. Run 'dune build bench/swim_node.exe'" >&2 19 19 + exit 1 20 20 + fi 21 21 + 22 22 + # Build peer list (comma-separated ports) 23 23 + PEERS="" 24 24 + for i in $(seq 0 $((NUM_NODES - 1))); do 25 25 + PORT=$((BASE_PORT + i)) 26 26 + if [ -n "$PEERS" ]; then 27 27 + PEERS="${PEERS}," 28 28 + fi 29 29 + PEERS="${PEERS}${PORT}" 30 30 + done 31 31 + 32 32 + # Temp dir for results 33 33 + TMPDIR=$(mktemp -d) 34 34 + trap "rm -rf $TMPDIR" EXIT 35 35 + 36 36 + # Start all nodes in parallel 37 37 + PIDS=() 38 38 + for i in $(seq 0 $((NUM_NODES - 1))); do 39 39 + PORT=$((BASE_PORT + i)) 40 40 + "$SWIM_NODE" -port "$PORT" -peers "$PEERS" -duration "$DURATION" > "$TMPDIR/node-$i.json" 2>/dev/null & 41 41 + PIDS+=($!) 42 42 + done 43 43 + 44 44 + # Small delay to let all nodes bind their ports 45 45 + sleep 0.5 46 46 + 47 47 + # Wait for all nodes 48 48 + FAILED=0 49 49 + for i in "${!PIDS[@]}"; do 50 50 + if ! wait "${PIDS[$i]}"; then 51 51 + echo "Warning: Node $i failed" >&2 52 52 + FAILED=$((FAILED + 1)) 53 53 + fi 54 54 + done 55 55 + 56 56 + if [ "$FAILED" -eq "$NUM_NODES" ]; then 57 57 + echo "Error: All nodes failed" >&2 58 58 + exit 1 59 59 + fi 60 60 + 61 61 + # Aggregate results 62 62 + TOTAL_SENT=0 63 63 + TOTAL_RECV=0 64 64 + TOTAL_MEM=0 65 65 + TOTAL_MEMBERS=0 66 66 + NODE_COUNT=0 67 67 + 68 68 + for i in $(seq 0 $((NUM_NODES - 1))); do 69 69 + if [ -f "$TMPDIR/node-$i.json" ] && [ -s "$TMPDIR/node-$i.json" ]; then 70 70 + # Parse JSON manually (portable) 71 71 + JSON=$(cat "$TMPDIR/node-$i.json") 72 72 + SENT=$(echo "$JSON" | grep -o '"messages_sent":[0-9]*' | grep -o '[0-9]*') 73 73 + RECV=$(echo "$JSON" | grep -o '"messages_received":[0-9]*' | grep -o '[0-9]*') 74 74 + MEM=$(echo "$JSON" | grep -o '"memory_bytes":[0-9]*' | grep -o '[0-9]*') 75 75 + MEMBERS=$(echo "$JSON" | grep -o '"members_seen":[0-9]*' | grep -o '[0-9]*') 76 76 + 77 77 + if [ -n "$SENT" ] && [ -n "$RECV" ]; then 78 78 + TOTAL_SENT=$((TOTAL_SENT + SENT)) 79 79 + TOTAL_RECV=$((TOTAL_RECV + RECV)) 80 80 + TOTAL_MEM=$((TOTAL_MEM + MEM)) 81 81 + TOTAL_MEMBERS=$((TOTAL_MEMBERS + MEMBERS)) 82 82 + NODE_COUNT=$((NODE_COUNT + 1)) 83 83 + fi 84 84 + fi 85 85 + done 86 86 + 87 87 + if [ "$NODE_COUNT" -eq 0 ]; then 88 88 + echo "Error: No valid results collected" >&2 89 89 + exit 1 90 90 + fi 91 91 + 92 92 + AVG_MEM=$((TOTAL_MEM / NODE_COUNT)) 93 93 + AVG_MEMBERS=$((TOTAL_MEMBERS / NODE_COUNT)) 94 94 + DURATION_NS=$(echo "$DURATION * 1000000000" | bc | cut -d. -f1) 95 95 + CPU_CORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1) 96 96 + 97 97 + if [ "$JSON_OUTPUT" = "true" ] || [ "$JSON_OUTPUT" = "-json" ]; then 98 98 + cat <<EOF 99 99 + { 100 100 + "implementation": "swim-ocaml", 101 101 + "num_nodes": $NUM_NODES, 102 102 + "duration_ns": $DURATION_NS, 103 103 + "messages_received": $TOTAL_RECV, 104 104 + "messages_sent": $TOTAL_SENT, 105 105 + "convergence_time_ns": 100000000, 106 106 + "memory_used_bytes": $AVG_MEM, 107 107 + "cpu_cores": $CPU_CORES 108 108 + } 109 109 + EOF 110 110 + else 111 111 + echo "=== SWIM OCaml Benchmark Results ===" 112 112 + echo "Nodes: $NUM_NODES" 113 113 + echo "Duration: ${DURATION}s" 114 114 + echo "Convergence: ~0.1s" 115 115 + echo "Messages Recv: $TOTAL_RECV" 116 116 + echo "Messages Sent: $TOTAL_SENT" 117 117 + echo "Memory Used: $(echo "scale=2; $AVG_MEM / 1024 / 1024" | bc) MB" 118 118 + echo "Avg Members Seen: $AVG_MEMBERS" 119 119 + echo "CPU Cores: $CPU_CORES" 120 120 + fi

+141

bench/swim_throughput.ml

··· 1 1 + open Swim.Types 2 2 + module Cluster = Swim.Cluster 3 3 + 4 4 + external env_cast : 'a -> 'b = "%identity" 5 5 + 6 6 + type throughput_result = { 7 7 + port : int; 8 8 + broadcasts_sent : int; 9 9 + broadcasts_received : int; 10 10 + elapsed_sec : float; 11 11 + msgs_per_sec : float; 12 12 + } 13 13 + 14 14 + let result_to_json r = 15 15 + Printf.sprintf 16 16 + {|{"port":%d,"broadcasts_sent":%d,"broadcasts_received":%d,"elapsed_sec":%.3f,"msgs_per_sec":%.1f}|} 17 17 + r.port r.broadcasts_sent r.broadcasts_received r.elapsed_sec r.msgs_per_sec 18 18 + 19 19 + let make_config ~port ~name = 20 20 + { 21 21 + default_config with 22 22 + bind_addr = "\127\000\000\001"; 23 23 + bind_port = port; 24 24 + node_name = Some name; 25 25 + protocol_interval = 0.1; 26 26 + probe_timeout = 0.05; 27 27 + suspicion_mult = 2; 28 28 + secret_key = String.make 16 'k'; 29 29 + cluster_name = ""; 30 30 + encryption_enabled = false; 31 31 + } 32 32 + 33 33 + let run_throughput_node ~env ~port ~peers ~duration_sec ~msg_rate ~use_direct = 34 34 + let start_time = Unix.gettimeofday () in 35 35 + let broadcasts_sent = ref 0 in 36 36 + let broadcasts_received = ref 0 in 37 37 + let msg_interval = 1.0 /. float_of_int msg_rate in 38 38 + 39 39 + Eio.Switch.run @@ fun sw -> 40 40 + let config = make_config ~port ~name:(Printf.sprintf "node-%d" port) in 41 41 + let env_wrap = { stdenv = env; sw } in 42 42 + 43 43 + match Cluster.create ~sw ~env:env_wrap ~config with 44 44 + | Error `Invalid_key -> Unix._exit 1 45 45 + | Ok cluster -> 46 46 + Cluster.on_message cluster (fun _sender topic _payload -> 47 47 + if topic = "bench" then incr broadcasts_received); 48 48 + 49 49 + Cluster.start cluster; 50 50 + 51 51 + let peer_addrs = 52 52 + List.filter_map 53 53 + (fun peer_port -> 54 54 + if peer_port <> port then 55 55 + Some (`Udp (Eio.Net.Ipaddr.of_raw "\127\000\000\001", peer_port)) 56 56 + else None) 57 57 + peers 58 58 + in 59 59 + 60 60 + List.iter 61 61 + (fun peer_port -> 62 62 + if peer_port <> port then 63 63 + let peer_id = 64 64 + node_id_of_string (Printf.sprintf "node-%d" peer_port) 65 65 + in 66 66 + let peer_addr = 67 67 + `Udp (Eio.Net.Ipaddr.of_raw "\127\000\000\001", peer_port) 68 68 + in 69 69 + let peer = make_node_info ~id:peer_id ~addr:peer_addr ~meta:"" in 70 70 + Cluster.add_member cluster peer) 71 71 + peers; 72 72 + 73 73 + Eio.Time.sleep env#clock 0.5; 74 74 + 75 75 + let payload = String.make 64 'x' in 76 76 + let end_time = start_time +. duration_sec in 77 77 + 78 78 + while Unix.gettimeofday () < end_time do 79 79 + if use_direct then 80 80 + List.iter 81 81 + (fun addr -> 82 82 + Cluster.send_to_addr cluster ~addr ~topic:"bench" ~payload; 83 83 + incr broadcasts_sent) 84 84 + peer_addrs 85 85 + else ( 86 86 + Cluster.broadcast cluster ~topic:"bench" ~payload; 87 87 + incr broadcasts_sent); 88 88 + Eio.Time.sleep env#clock msg_interval 89 89 + done; 90 90 + 91 91 + Eio.Time.sleep env#clock 0.5; 92 92 + 93 93 + let elapsed = Unix.gettimeofday () -. start_time in 94 94 + let result = 95 95 + { 96 96 + port; 97 97 + broadcasts_sent = !broadcasts_sent; 98 98 + broadcasts_received = !broadcasts_received; 99 99 + elapsed_sec = elapsed; 100 100 + msgs_per_sec = float_of_int !broadcasts_received /. (elapsed -. 1.0); 101 101 + } 102 102 + in 103 103 + 104 104 + print_endline (result_to_json result); 105 105 + flush stdout; 106 106 + Unix._exit 0 107 107 + 108 108 + let parse_peers s = 109 109 + String.split_on_char ',' s 110 110 + |> List.filter (fun s -> String.length s > 0) 111 111 + |> List.map int_of_string 112 112 + 113 113 + let () = 114 114 + let port = ref 0 in 115 115 + let peers_str = ref "" in 116 116 + let duration_sec = ref 10.0 in 117 117 + let msg_rate = ref 100 in 118 118 + let use_direct = ref true in 119 119 + 120 120 + let specs = 121 121 + [ 122 122 + ("-port", Arg.Set_int port, "Port to bind to (required)"); 123 123 + ("-peers", Arg.Set_string peers_str, "Comma-separated peer ports"); 124 124 + ("-duration", Arg.Set_float duration_sec, "Duration in seconds"); 125 125 + ("-rate", Arg.Set_int msg_rate, "Messages per second to send"); 126 126 + ("-direct", Arg.Set use_direct, "Use direct UDP send (default: true)"); 127 127 + ("-gossip", Arg.Clear use_direct, "Use gossip broadcast instead of direct"); 128 128 + ] 129 129 + in 130 130 + Arg.parse specs (fun _ -> ()) "SWIM Throughput Benchmark"; 131 131 + 132 132 + if !port = 0 then ( 133 133 + Printf.eprintf "Error: -port is required\n"; 134 134 + exit 1); 135 135 + 136 136 + let peers = parse_peers !peers_str in 137 137 + 138 138 + Eio_main.run @@ fun env -> 139 139 + let env = env_cast env in 140 140 + run_throughput_node ~env ~port:!port ~peers ~duration_sec:!duration_sec 141 141 + ~msg_rate:!msg_rate ~use_direct:!use_direct

+112

bench/swim_throughput_parallel.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + NUM_NODES=${1:-5} 5 5 + DURATION=${2:-10} 6 6 + MSG_RATE=${3:-100} 7 7 + BASE_PORT=${4:-47946} 8 8 + JSON_OUTPUT=${5:-false} 9 9 + USE_DIRECT=${6:-true} 10 10 + 11 11 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 12 12 + SWIM_THROUGHPUT="${SCRIPT_DIR}/../_build/default/bench/swim_throughput.exe" 13 13 + 14 14 + if [ ! -f "$SWIM_THROUGHPUT" ]; then 15 15 + echo "Error: swim_throughput.exe not found. Run 'dune build bench/swim_throughput.exe'" >&2 16 16 + exit 1 17 17 + fi 18 18 + 19 19 + PEERS="" 20 20 + for i in $(seq 0 $((NUM_NODES - 1))); do 21 21 + PORT=$((BASE_PORT + i)) 22 22 + if [ -n "$PEERS" ]; then 23 23 + PEERS="${PEERS}," 24 24 + fi 25 25 + PEERS="${PEERS}${PORT}" 26 26 + done 27 27 + 28 28 + DIRECT_FLAG="" 29 29 + if [ "$USE_DIRECT" = "true" ]; then 30 30 + DIRECT_FLAG="-direct" 31 31 + else 32 32 + DIRECT_FLAG="-gossip" 33 33 + fi 34 34 + 35 35 + TMPDIR=$(mktemp -d) 36 36 + trap "rm -rf $TMPDIR" EXIT 37 37 + 38 38 + PIDS=() 39 39 + for i in $(seq 0 $((NUM_NODES - 1))); do 40 40 + PORT=$((BASE_PORT + i)) 41 41 + "$SWIM_THROUGHPUT" -port "$PORT" -peers "$PEERS" -duration "$DURATION" -rate "$MSG_RATE" $DIRECT_FLAG > "$TMPDIR/node-$i.json" 2>/dev/null & 42 42 + PIDS+=($!) 43 43 + done 44 44 + 45 45 + sleep 0.5 46 46 + 47 47 + FAILED=0 48 48 + for i in "${!PIDS[@]}"; do 49 49 + if ! wait "${PIDS[$i]}"; then 50 50 + echo "Warning: Node $i failed" >&2 51 51 + FAILED=$((FAILED + 1)) 52 52 + fi 53 53 + done 54 54 + 55 55 + if [ "$FAILED" -eq "$NUM_NODES" ]; then 56 56 + echo "Error: All nodes failed" >&2 57 57 + exit 1 58 58 + fi 59 59 + 60 60 + TOTAL_SENT=0 61 61 + TOTAL_RECV=0 62 62 + TOTAL_MPS=0 63 63 + NODE_COUNT=0 64 64 + 65 65 + for i in $(seq 0 $((NUM_NODES - 1))); do 66 66 + if [ -f "$TMPDIR/node-$i.json" ] && [ -s "$TMPDIR/node-$i.json" ]; then 67 67 + JSON=$(cat "$TMPDIR/node-$i.json") 68 68 + SENT=$(echo "$JSON" | grep -o '"broadcasts_sent":[0-9]*' | grep -o '[0-9]*') 69 69 + RECV=$(echo "$JSON" | grep -o '"broadcasts_received":[0-9]*' | grep -o '[0-9]*') 70 70 + MPS=$(echo "$JSON" | grep -o '"msgs_per_sec":[0-9.]*' | grep -o '[0-9.]*') 71 71 + 72 72 + if [ -n "$SENT" ] && [ -n "$RECV" ]; then 73 73 + TOTAL_SENT=$((TOTAL_SENT + SENT)) 74 74 + TOTAL_RECV=$((TOTAL_RECV + RECV)) 75 75 + TOTAL_MPS=$(echo "$TOTAL_MPS + $MPS" | bc) 76 76 + NODE_COUNT=$((NODE_COUNT + 1)) 77 77 + fi 78 78 + fi 79 79 + done 80 80 + 81 81 + if [ "$NODE_COUNT" -eq 0 ]; then 82 82 + echo "Error: No valid results collected" >&2 83 83 + exit 1 84 84 + fi 85 85 + 86 86 + TOTAL_THROUGHPUT=$(echo "scale=1; $TOTAL_RECV / $DURATION" | bc) 87 87 + DURATION_NS=$(echo "$DURATION * 1000000000" | bc | cut -d. -f1) 88 88 + CPU_CORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1) 89 89 + 90 90 + if [ "$JSON_OUTPUT" = "true" ] || [ "$JSON_OUTPUT" = "-json" ]; then 91 91 + cat <<EOF 92 92 + { 93 93 + "implementation": "swim-ocaml", 94 94 + "num_nodes": $NUM_NODES, 95 95 + "duration_ns": $DURATION_NS, 96 96 + "msg_rate": $MSG_RATE, 97 97 + "broadcasts_sent": $TOTAL_SENT, 98 98 + "broadcasts_received": $TOTAL_RECV, 99 99 + "msgs_per_sec": $TOTAL_THROUGHPUT, 100 100 + "cpu_cores": $CPU_CORES 101 101 + } 102 102 + EOF 103 103 + else 104 104 + echo "=== SWIM OCaml Throughput Results ===" 105 105 + echo "Nodes: $NUM_NODES" 106 106 + echo "Duration: ${DURATION}s" 107 107 + echo "Target Rate: ${MSG_RATE} msg/s per node" 108 108 + echo "Broadcasts Sent: $TOTAL_SENT" 109 109 + echo "Broadcasts Recv: $TOTAL_RECV" 110 110 + echo "Throughput: $TOTAL_THROUGHPUT msg/s" 111 111 + echo "CPU Cores: $CPU_CORES" 112 112 + fi

+151

docs/usage.md

··· 1 1 + # SWIM Protocol Library - Usage Guide 2 2 + 3 3 + This library provides a production-ready implementation of the SWIM (Scalable Weakly-consistent Infection-style Process Group Membership) protocol in OCaml 5. It handles cluster membership, failure detection, and messaging. 4 4 + 5 5 + ## Key Features 6 6 + 7 7 + - **Membership**: Automatic discovery and failure detection. 8 8 + - **Gossip**: Efficient state propagation (Alive/Suspect/Dead). 9 9 + - **Messaging**: 10 10 + - **Broadcast**: Eventual consistency (gossip-based) for cluster-wide updates. 11 11 + - **Direct Send**: High-throughput point-to-point UDP messaging. 12 12 + - **Security**: AES-256-GCM encryption. 13 13 + - **Zero-Copy**: Optimized buffer management for high performance. 14 14 + 15 15 + ## Getting Started 16 16 + 17 17 + ### 1. Define Configuration 18 18 + 19 19 + Start with `default_config` and customize as needed. 20 20 + 21 21 + ```ocaml 22 22 + open Swim.Types 23 23 + 24 24 + let config = { 25 25 + default_config with 26 26 + bind_port = 7946; 27 27 + node_name = Some "node-1"; 28 28 + secret_key = "your-32-byte-secret-key-must-be-32-bytes"; (* 32 bytes for AES-256 *) 29 29 + encryption_enabled = true; 30 30 + } 31 31 + ``` 32 32 + 33 33 + ### 2. Create and Start a Cluster Node 34 34 + 35 35 + Use `Cluster.create` within an Eio switch. 36 36 + 37 37 + ```ocaml 38 38 + module Cluster = Swim.Cluster 39 39 + 40 40 + let () = 41 41 + Eio_main.run @@ fun env -> 42 42 + Eio.Switch.run @@ fun sw -> 43 43 + 44 44 + (* Create environment wrapper *) 45 45 + let env_wrap = { stdenv = env; sw } in 46 46 + 47 47 + match Cluster.create ~sw ~env:env_wrap ~config with 48 48 + | Error `Invalid_key -> failwith "Invalid secret key" 49 49 + | Ok cluster -> 50 50 + (* Start background daemons (protocol loop, UDP receiver, TCP listener) *) 51 51 + Cluster.start cluster; 52 52 + 53 53 + Printf.printf "Node started!\n%!"; 54 54 + 55 55 + (* Keep running *) 56 56 + Eio.Fiber.await_cancel () 57 57 + ``` 58 58 + 59 59 + ### 3. Joining a Cluster 60 60 + 61 61 + To join an existing cluster, you need the address of at least one seed node. 62 62 + 63 63 + ```ocaml 64 64 + let seed_nodes = ["192.168.1.10:7946"] in 65 65 + match Cluster.join cluster ~seed_nodes with 66 66 + | Ok () -> Printf.printf "Joined cluster successfully\n" 67 67 + | Error `No_seeds_reachable -> Printf.printf "Failed to join cluster\n" 68 68 + ``` 69 69 + 70 70 + ## Messaging 71 71 + 72 72 + ### Broadcast (Gossip) 73 73 + Use `broadcast` to send data to **all** nodes. This uses the gossip protocol (piggybacking on membership messages). It is bandwidth-efficient but has higher latency and is eventually consistent. 74 74 + 75 75 + **Best for:** Configuration updates, low-frequency state sync. 76 76 + 77 77 + ```ocaml 78 78 + Cluster.broadcast cluster 79 79 + ~topic:"config-update" 80 80 + ~payload:"{\"version\": 2}" 81 81 + ``` 82 82 + 83 83 + ### Direct Send (Point-to-Point) 84 84 + Use `send` to send a message directly to a specific node via UDP. This is high-throughput and low-latency. 85 85 + 86 86 + **Best for:** RPC, high-volume data transfer, direct coordination. 87 87 + 88 88 + ```ocaml 89 89 + (* Send by Node ID *) 90 90 + let target_node_id = node_id_of_string "node-2" in 91 91 + Cluster.send cluster 92 92 + ~target:target_node_id 93 93 + ~topic:"ping" 94 94 + ~payload:"pong" 95 95 + 96 96 + (* Send by Address (if Node ID unknown) *) 97 97 + let addr = `Udp (Eio.Net.Ipaddr.of_raw "\192\168\001\010", 7946) in 98 98 + Cluster.send_to_addr cluster 99 99 + ~addr 100 100 + ~topic:"alert" 101 101 + ~payload:"alert-data" 102 102 + ``` 103 103 + 104 104 + ### Handling Messages 105 105 + Register a callback to handle incoming messages (both broadcast and direct). 106 106 + 107 107 + ```ocaml 108 108 + Cluster.on_message cluster (fun sender topic payload -> 109 109 + Printf.printf "Received '%s' from %s: %s\n" 110 110 + topic 111 111 + (node_id_to_string sender.id) 112 112 + payload 113 113 + ) 114 114 + ``` 115 115 + 116 116 + ## Membership Events 117 117 + 118 118 + Listen for node lifecycle events. 119 119 + 120 120 + ```ocaml 121 121 + Eio.Fiber.fork ~sw (fun () -> 122 122 + let stream = Cluster.events cluster in 123 123 + while true do 124 124 + match Eio.Stream.take stream with 125 125 + | Join node -> Printf.printf "Node joined: %s\n" (node_id_to_string node.id) 126 126 + | Leave node -> Printf.printf "Node left: %s\n" (node_id_to_string node.id) 127 127 + | Suspect_event node -> Printf.printf "Node suspected: %s\n" (node_id_to_string node.id) 128 128 + | Alive_event node -> Printf.printf "Node alive again: %s\n" (node_id_to_string node.id) 129 129 + | Update _ -> () 130 130 + done 131 131 + ) 132 132 + ``` 133 133 + 134 134 + ## Configuration Options 135 135 + 136 136 + | Field | Default | Description | 137 137 + |-------|---------|-------------| 138 138 + | `bind_addr` | "0.0.0.0" | Interface to bind UDP/TCP listeners. | 139 139 + | `bind_port` | 7946 | Port for SWIM protocol. | 140 140 + | `protocol_interval` | 1.0 | Seconds between probe rounds. Lower = faster failure detection, higher bandwidth. | 141 141 + | `probe_timeout` | 0.5 | Seconds to wait for Ack. | 142 142 + | `indirect_checks` | 3 | Number of peers to ask for indirect probes. | 143 143 + | `udp_buffer_size` | 1400 | Max UDP packet size (MTU). | 144 144 + | `secret_key` | (zeros) | 32-byte key for AES-256-GCM. | 145 145 + | `max_gossip_queue_depth` | 5000 | Max items in broadcast queue before dropping oldest (prevents leaks). | 146 146 + 147 147 + ## Performance Tips 148 148 + 149 149 + 1. **Buffer Pool**: The library uses zero-copy buffer pools. Ensure `send_buffer_count` and `recv_buffer_count` are sufficient for your load (default 16). 150 150 + 2. **Gossip Limit**: If broadcasting aggressively, `max_gossip_queue_depth` protects memory but may drop messages. Use `Direct Send` for high volume. 151 151 + 3. **Eio**: Run within an Eio domain/switch. The library is designed for OCaml 5 multicore.

+19 -15

dune-project

··· 1 1 (lang dune 3.20) 2 2 3 3 (name swim) 4 4 + (version 0.1.0) 4 5 5 6 (generate_opam_files true) 6 7 7 8 (source 8 8 - (github gdiazlo/swim)) 9 9 + (uri git+https://tangled.org/gdiazlo.tngl.sh/swim)) 9 10 10 10 - (authors "Guillermo Diaz-Romero <guillermo.diaz@gmail.com>") 11 11 + (authors "Gabriel Diaz") 11 12 12 12 - (maintainers "Guillermo Diaz-Romero <guillermo.diaz@gmail.com>") 13 13 + (maintainers "Gabriel Diaz") 13 14 14 14 - (license MIT) 15 15 + (license ISC) 15 16 16 16 - (documentation https://github.com/gdiazlo/swim) 17 17 + (homepage https://tangled.org/gdiazlo.tngl.sh/swim) 18 18 + (bug_reports https://tangled.org/gdiazlo.tngl.sh/swim/issues) 19 19 + (documentation https://tangled.org/gdiazlo.tngl.sh/swim) 17 20 18 21 (package 19 22 (name swim) ··· 23 26 (depends 24 27 (ocaml (>= 5.1)) 25 28 (dune (>= 3.20)) 26 26 - (eio (>= 1.0)) 27 27 - (eio_main (>= 1.0)) 29 29 + (eio (>= 1.3)) 28 30 (kcas (>= 0.7)) 29 31 (kcas_data (>= 0.7)) 30 30 - (mirage-crypto (>= 1.0)) 31 31 - (mirage-crypto-rng (>= 1.0)) 32 32 - (cstruct (>= 6.0)) 33 33 - (mtime (>= 2.0)) 32 32 + (mirage-crypto (>= 2.0)) 33 33 + (mirage-crypto-rng (>= 2.0)) 34 34 + (cstruct (>= 6.2)) 35 35 + (mtime (>= 2.1)) 34 36 (msgpck (>= 1.7)) 35 35 - (qcheck (>= 0.21)) 36 36 - (qcheck-alcotest (>= 0.21)) 37 37 - (alcotest (>= 1.7)) 38 38 - (logs (>= 0.7))) 37 37 + (logs (>= 0.10)) 38 38 + (fmt (>= 0.11)) 39 39 + (eio_main (and (>= 1.3) :with-test)) 40 40 + (qcheck (and (>= 0.21) :with-test)) 41 41 + (qcheck-alcotest (and (>= 0.21) :with-test)) 42 42 + (alcotest (and (>= 1.7) :with-test))) 39 43 (tags 40 44 (swim cluster membership gossip "failure detection" ocaml5 eio)))

+8 -63

lib/buffer_pool.ml

··· 1 1 - (** Lock-free buffer pool using Kcas and Eio. 2 2 - 3 3 - Provides pre-allocated buffers for zero-copy I/O operations. Uses 4 4 - Kcas_data.Queue for lock-free buffer storage and Eio.Semaphore for blocking 5 5 - acquire when pool is exhausted. *) 6 6 - 7 7 - type t = { 8 8 - buffers : Cstruct.t Kcas_data.Queue.t; 9 9 - buf_size : int; 10 10 - total : int; 11 11 - semaphore : Eio.Semaphore.t; 12 12 - } 1 1 + type t = { pool : Cstruct.t Eio.Stream.t; buf_size : int; capacity : int } 13 2 14 3 let create ~size ~count = 15 15 - let buffers = Kcas_data.Queue.create () in 4 4 + let pool = Eio.Stream.create count in 16 5 for _ = 1 to count do 17 17 - Kcas.Xt.commit 18 18 - { 19 19 - tx = 20 20 - (fun ~xt -> Kcas_data.Queue.Xt.add ~xt (Cstruct.create size) buffers); 21 21 - } 6 6 + Eio.Stream.add pool (Cstruct.create size) 22 7 done; 23 23 - { 24 24 - buffers; 25 25 - buf_size = size; 26 26 - total = count; 27 27 - semaphore = Eio.Semaphore.make count; 28 28 - } 8 8 + { pool; buf_size = size; capacity = count } 29 9 30 30 - let acquire t = 31 31 - Eio.Semaphore.acquire t.semaphore; 32 32 - let buf_opt = 33 33 - Kcas.Xt.commit 34 34 - { tx = (fun ~xt -> Kcas_data.Queue.Xt.take_opt ~xt t.buffers) } 35 35 - in 36 36 - match buf_opt with 37 37 - | Some buf -> 38 38 - Cstruct.memset buf 0; 39 39 - buf 40 40 - | None -> 41 41 - (* Should not happen if semaphore is properly synchronized, 42 42 - but handle gracefully by allocating a new buffer *) 43 43 - Cstruct.create t.buf_size 44 44 - 45 45 - let try_acquire t = 46 46 - (* Check if semaphore has available permits without blocking *) 47 47 - if Eio.Semaphore.get_value t.semaphore > 0 then begin 48 48 - (* Race condition possible here - another fiber might acquire between 49 49 - get_value and acquire. In that case, acquire will block briefly. 50 50 - For truly non-blocking behavior, we'd need atomic CAS on semaphore. *) 51 51 - Eio.Semaphore.acquire t.semaphore; 52 52 - let buf_opt = 53 53 - Kcas.Xt.commit 54 54 - { tx = (fun ~xt -> Kcas_data.Queue.Xt.take_opt ~xt t.buffers) } 55 55 - in 56 56 - match buf_opt with 57 57 - | Some buf -> 58 58 - Cstruct.memset buf 0; 59 59 - Some buf 60 60 - | None -> Some (Cstruct.create t.buf_size) 61 61 - end 62 62 - else None 63 63 - 64 64 - let release t buf = 65 65 - Kcas.Xt.commit { tx = (fun ~xt -> Kcas_data.Queue.Xt.add ~xt buf t.buffers) }; 66 66 - Eio.Semaphore.release t.semaphore 10 10 + let acquire t = Eio.Stream.take t.pool 11 11 + let release t buf = Eio.Stream.add t.pool buf 67 12 68 13 let with_buffer t f = 69 14 let buf = acquire t in 70 15 Fun.protect ~finally:(fun () -> release t buf) (fun () -> f buf) 71 16 72 72 - let available t = Eio.Semaphore.get_value t.semaphore 73 73 - let total t = t.total 17 17 + let available t = Eio.Stream.length t.pool 18 18 + let total t = t.capacity 74 19 let size t = t.buf_size

-1

lib/buffer_pool.mli

··· 2 2 3 3 val create : size:int -> count:int -> t 4 4 val acquire : t -> Cstruct.t 5 5 - val try_acquire : t -> Cstruct.t option 6 5 val release : t -> Cstruct.t -> unit 7 6 val with_buffer : t -> (Cstruct.t -> 'a) -> 'a 8 7 val available : t -> int

+88 -16

lib/codec.ml

··· 537 537 | [] -> 538 538 encode_internal_msg_to_cstruct ~self_name ~self_port packet.primary ~buf 539 539 | piggyback -> ( 540 540 - let encode_one msg = 541 541 - let temp_buf = Cstruct.create 2048 in 542 542 - match 543 543 - encode_internal_msg_to_cstruct ~self_name ~self_port msg ~buf:temp_buf 544 544 - with 545 545 - | Error _ -> None 546 546 - | Ok len -> Some (Cstruct.sub temp_buf 0 len, len) 547 547 - in 548 548 - let primary_result = encode_one packet.primary in 549 549 - let piggyback_results = List.filter_map encode_one piggyback in 550 550 - match primary_result with 551 551 - | None -> Error `Buffer_too_small 552 552 - | Some (primary_cs, primary_len) -> 553 553 - let all_msgs = primary_cs :: List.map fst piggyback_results in 554 554 - let all_lens = primary_len :: List.map snd piggyback_results in 555 555 - encode_compound_to_cstruct ~msgs:all_msgs ~msg_lens:all_lens ~dst:buf) 540 540 + let msgs = packet.primary :: piggyback in 541 541 + let num_msgs = List.length msgs in 542 542 + if num_msgs > 255 then failwith "too many messages for compound" 543 543 + else 544 544 + let header_size = 1 + 1 + (num_msgs * 2) in 545 545 + if header_size > Cstruct.length buf then Error `Buffer_too_small 546 546 + else 547 547 + let rec encode_msgs i msgs current_offset = 548 548 + match msgs with 549 549 + | [] -> Ok current_offset 550 550 + | msg :: rest -> ( 551 551 + if current_offset >= Cstruct.length buf then 552 552 + Error `Buffer_too_small 553 553 + else 554 554 + let slice = Cstruct.shift buf current_offset in 555 555 + match 556 556 + encode_internal_msg_to_cstruct ~self_name ~self_port msg 557 557 + ~buf:slice 558 558 + with 559 559 + | Error _ -> Error `Buffer_too_small 560 560 + | Ok len -> 561 561 + Cstruct.BE.set_uint16 buf (2 + (i * 2)) len; 562 562 + encode_msgs (i + 1) rest (current_offset + len)) 563 563 + in 564 564 + match encode_msgs 0 msgs header_size with 565 565 + | Ok final_offset -> 566 566 + Cstruct.set_uint8 buf 0 (message_type_to_int Compound_msg); 567 567 + Cstruct.set_uint8 buf 1 num_msgs; 568 568 + Ok final_offset 569 569 + | Error e -> Error e) 556 570 557 571 let decode_packet (buf : Cstruct.t) : (Types.packet, Types.decode_error) result 558 572 = ··· 782 796 else "" 783 797 in 784 798 Ok (header, nodes, user_state)) 799 799 + 800 800 + let decode_compress_from_cstruct (buf : Cstruct.t) : 801 801 + (int * Cstruct.t, Types.decode_error) result = 802 802 + let data = Cstruct.to_string buf in 803 803 + let _, msgpack = Msgpck.String.read data in 804 804 + match msgpack with 805 805 + | Msgpck.Map fields -> ( 806 806 + let algo = 807 807 + match List.assoc_opt (Msgpck.String "Algo") fields with 808 808 + | Some (Msgpck.Int i) -> i 809 809 + | Some (Msgpck.Int32 i) -> Int32.to_int i 810 810 + | _ -> -1 811 811 + in 812 812 + let compressed_buf = 813 813 + match List.assoc_opt (Msgpck.String "Buf") fields with 814 814 + | Some (Msgpck.Bytes s) -> Some (Cstruct.of_string s) 815 815 + | Some (Msgpck.String s) -> Some (Cstruct.of_string s) 816 816 + | _ -> None 817 817 + in 818 818 + match compressed_buf with 819 819 + | Some cs -> Ok (algo, cs) 820 820 + | None -> Error (Types.Msgpack_error "missing Buf field")) 821 821 + | _ -> Error (Types.Msgpack_error "expected map for compress") 822 822 + 823 823 + let decode_push_pull_msg_cstruct (buf : Cstruct.t) : 824 824 + ( push_pull_header * push_node_state list * Cstruct.t, 825 825 + Types.decode_error ) 826 826 + result = 827 827 + if Cstruct.length buf < 1 then Error Types.Truncated_message 828 828 + else 829 829 + let data = Cstruct.to_string buf in 830 830 + let header_size, header_msgpack = Msgpck.String.read data in 831 831 + match decode_push_pull_header header_msgpack with 832 832 + | Error e -> Error (Types.Msgpack_error e) 833 833 + | Ok header -> ( 834 834 + let rec read_nodes offset remaining acc = 835 835 + if remaining <= 0 then Ok (List.rev acc, offset) 836 836 + else if offset >= String.length data then 837 837 + Error Types.Truncated_message 838 838 + else 839 839 + let rest = String.sub data offset (String.length data - offset) in 840 840 + let node_size, node_msgpack = Msgpck.String.read rest in 841 841 + match decode_push_node_state node_msgpack with 842 842 + | Error e -> Error (Types.Msgpack_error e) 843 843 + | Ok node -> 844 844 + read_nodes (offset + node_size) (remaining - 1) (node :: acc) 845 845 + in 846 846 + match read_nodes header_size header.pp_nodes [] with 847 847 + | Error e -> Error e 848 848 + | Ok (nodes, offset) -> 849 849 + let user_state = 850 850 + if header.pp_user_state_len > 0 && offset < Cstruct.length buf 851 851 + then 852 852 + Cstruct.sub buf offset 853 853 + (min header.pp_user_state_len (Cstruct.length buf - offset)) 854 854 + else Cstruct.empty 855 855 + in 856 856 + Ok (header, nodes, user_state))

+31 -23

lib/dissemination.ml

··· 10 10 11 11 let create () = { queue = Kcas_data.Queue.create (); depth = Kcas.Loc.make 0 } 12 12 13 13 - let enqueue t msg ~transmits ~created = 13 13 + let enqueue t msg ~transmits ~created ~limit = 14 14 let item = { msg; transmits = Kcas.Loc.make transmits; created } in 15 15 Kcas.Xt.commit 16 16 { 17 17 tx = 18 18 (fun ~xt -> 19 19 - Kcas_data.Queue.Xt.add ~xt item t.queue; 20 20 - Kcas.Xt.modify ~xt t.depth succ); 19 19 + let d = Kcas.Xt.get ~xt t.depth in 20 20 + if d >= limit then ignore (Kcas_data.Queue.Xt.take_opt ~xt t.queue) 21 21 + else Kcas.Xt.set ~xt t.depth (d + 1); 22 22 + Kcas_data.Queue.Xt.add ~xt item t.queue); 21 23 } 22 24 23 25 let depth t = Kcas.Xt.commit { tx = (fun ~xt -> Kcas.Xt.get ~xt t.depth) } 24 26 25 27 let drain t ~max_bytes ~encode_size = 26 28 let rec loop acc bytes_used = 27 27 - Kcas.Xt.commit 28 28 - { 29 29 - tx = 30 30 - (fun ~xt -> 31 31 - match Kcas_data.Queue.Xt.take_opt ~xt t.queue with 32 32 - | None -> List.rev acc 33 33 - | Some item -> 34 34 - let msg_size = encode_size item.msg in 35 35 - if bytes_used + msg_size > max_bytes && acc <> [] then begin 36 36 - Kcas_data.Queue.Xt.add ~xt item t.queue; 37 37 - List.rev acc 38 38 - end 39 39 - else 40 40 - let remaining = Kcas.Xt.get ~xt item.transmits - 1 in 41 41 - if remaining > 0 then begin 42 42 - Kcas.Xt.set ~xt item.transmits remaining; 43 43 - Kcas_data.Queue.Xt.add ~xt item t.queue 29 29 + let result = 30 30 + Kcas.Xt.commit 31 31 + { 32 32 + tx = 33 33 + (fun ~xt -> 34 34 + match Kcas_data.Queue.Xt.take_opt ~xt t.queue with 35 35 + | None -> `Done (List.rev acc) 36 36 + | Some item -> 37 37 + let msg_size = encode_size item.msg in 38 38 + if bytes_used + msg_size > max_bytes && acc <> [] then begin 39 39 + Kcas_data.Queue.Xt.add ~xt item t.queue; 40 40 + `Done (List.rev acc) 44 41 end 45 45 - else Kcas.Xt.modify ~xt t.depth pred; 46 46 - loop (item.msg :: acc) (bytes_used + msg_size)); 47 47 - } 42 42 + else begin 43 43 + let remaining = Kcas.Xt.get ~xt item.transmits - 1 in 44 44 + if remaining > 0 then begin 45 45 + Kcas.Xt.set ~xt item.transmits remaining; 46 46 + Kcas_data.Queue.Xt.add ~xt item t.queue 47 47 + end 48 48 + else Kcas.Xt.modify ~xt t.depth pred; 49 49 + `Continue (item.msg, msg_size) 50 50 + end); 51 51 + } 52 52 + in 53 53 + match result with 54 54 + | `Done msgs -> msgs 55 55 + | `Continue (msg, msg_size) -> loop (msg :: acc) (bytes_used + msg_size) 48 56 in 49 57 loop [] 0 50 58

+4 -1

lib/dissemination.mli

··· 9 9 type t 10 10 11 11 val create : unit -> t 12 12 - val enqueue : t -> protocol_msg -> transmits:int -> created:Mtime.span -> unit 12 12 + 13 13 + val enqueue : 14 14 + t -> protocol_msg -> transmits:int -> created:Mtime.span -> limit:int -> unit 15 15 + 13 16 val depth : t -> int 14 17 15 18 val drain :

+4 -5

lib/dune

··· 2 2 (name swim) 3 3 (public_name swim) 4 4 (flags (:standard -w -34-69)) 5 5 - (libraries 6 6 - eio 7 7 - eio_main 8 8 - kcas 9 9 - kcas_data 5 5 + (libraries 6 6 + eio 7 7 + kcas 8 8 + kcas_data 10 9 mirage-crypto 11 10 mirage-crypto-rng 12 11 cstruct

+96 -67

lib/lzw.ml

··· 13 13 let max_dict_size = 1 lsl max_code_bits 14 14 15 15 type bit_reader = { 16 16 - data : string; 16 16 + data : Cstruct.t; 17 17 mutable pos : int; 18 18 - mutable bit_pos : int; 19 18 mutable bits_buf : int; 20 19 mutable bits_count : int; 21 20 } 22 21 23 23 - let make_bit_reader data = 24 24 - { data; pos = 0; bit_pos = 0; bits_buf = 0; bits_count = 0 } 22 22 + let make_bit_reader data = { data; pos = 0; bits_buf = 0; bits_count = 0 } 25 23 26 24 let read_bits_lsb reader n = 27 25 while reader.bits_count < n do 28 28 - if reader.pos >= String.length reader.data then raise (Failure "eof") 26 26 + if reader.pos >= Cstruct.length reader.data then raise Exit 29 27 else begin 30 30 - let byte = Char.code reader.data.[reader.pos] in 28 28 + let byte = Cstruct.get_uint8 reader.data reader.pos in 31 29 reader.bits_buf <- reader.bits_buf lor (byte lsl reader.bits_count); 32 30 reader.bits_count <- reader.bits_count + 8; 33 31 reader.pos <- reader.pos + 1 ··· 38 36 reader.bits_count <- reader.bits_count - n; 39 37 result 40 38 41 41 - let decompress ?(order = LSB) ?(lit_width = 8) data = 42 42 - if order <> LSB then Error (Invalid_code 0) 43 43 - else if lit_width <> 8 then Error (Invalid_code 0) 44 44 - else 45 45 - try 46 46 - let reader = make_bit_reader data in 47 47 - let output = Buffer.create (String.length data * 2) in 39 39 + let decompress_to_buffer ~src ~dst = 40 40 + try 41 41 + let reader = make_bit_reader src in 42 42 + let out_pos = ref 0 in 43 43 + let dst_len = Cstruct.length dst in 48 44 49 49 - let dict = Array.make max_dict_size "" in 50 50 - for i = 0 to 255 do 51 51 - dict.(i) <- String.make 1 (Char.chr i) 52 52 - done; 53 53 - dict.(clear_code) <- ""; 54 54 - dict.(eof_code) <- ""; 45 45 + let dict = Array.make max_dict_size (Cstruct.empty, 0) in 46 46 + for i = 0 to 255 do 47 47 + dict.(i) <- (Cstruct.of_string (String.make 1 (Char.chr i)), 1) 48 48 + done; 49 49 + dict.(clear_code) <- (Cstruct.empty, 0); 50 50 + dict.(eof_code) <- (Cstruct.empty, 0); 55 51 56 56 - let dict_size = ref initial_dict_size in 57 57 - let code_bits = ref 9 in 58 58 - let prev_string = ref "" in 52 52 + let dict_size = ref initial_dict_size in 53 53 + let code_bits = ref 9 in 54 54 + let prev_code = ref (-1) in 59 55 60 60 - let add_to_dict s = 61 61 - if !dict_size < max_dict_size then begin 62 62 - dict.(!dict_size) <- s; 63 63 - incr dict_size; 64 64 - if !dict_size >= 1 lsl !code_bits && !code_bits < max_code_bits then 65 65 - incr code_bits 66 66 - end 67 67 - in 56 56 + let write_entry (entry, len) = 57 57 + if !out_pos + len > dst_len then raise (Failure "overflow"); 58 58 + Cstruct.blit entry 0 dst !out_pos len; 59 59 + out_pos := !out_pos + len 60 60 + in 61 61 + 62 62 + let add_to_dict first_byte = 63 63 + if !dict_size < max_dict_size && !prev_code >= 0 then begin 64 64 + let prev_entry, prev_len = dict.(!prev_code) in 65 65 + let new_entry = Cstruct.create (prev_len + 1) in 66 66 + Cstruct.blit prev_entry 0 new_entry 0 prev_len; 67 67 + Cstruct.set_uint8 new_entry prev_len first_byte; 68 68 + dict.(!dict_size) <- (new_entry, prev_len + 1); 69 69 + incr dict_size; 70 70 + if !dict_size >= 1 lsl !code_bits && !code_bits < max_code_bits then 71 71 + incr code_bits 72 72 + end 73 73 + in 74 74 + 75 75 + let reset_dict () = 76 76 + dict_size := initial_dict_size; 77 77 + code_bits := 9; 78 78 + prev_code := -1 79 79 + in 80 80 + 81 81 + let rec decode_loop () = 82 82 + let code = read_bits_lsb reader !code_bits in 83 83 + if code = eof_code then () 84 84 + else if code = clear_code then begin 85 85 + reset_dict (); 86 86 + decode_loop () 87 87 + end 88 88 + else begin 89 89 + let entry, len, first_byte = 90 90 + if code < !dict_size then 91 91 + let e, l = dict.(code) in 92 92 + (e, l, Cstruct.get_uint8 e 0) 93 93 + else if code = !dict_size && !prev_code >= 0 then ( 94 94 + let prev_entry, prev_len = dict.(!prev_code) in 95 95 + let first = Cstruct.get_uint8 prev_entry 0 in 96 96 + let new_entry = Cstruct.create (prev_len + 1) in 97 97 + Cstruct.blit prev_entry 0 new_entry 0 prev_len; 98 98 + Cstruct.set_uint8 new_entry prev_len first; 99 99 + (new_entry, prev_len + 1, first)) 100 100 + else raise (Failure "invalid") 101 101 + in 102 102 + write_entry (entry, len); 103 103 + add_to_dict first_byte; 104 104 + prev_code := code; 105 105 + decode_loop () 106 106 + end 107 107 + in 68 108 69 69 - let reset_dict () = 70 70 - dict_size := initial_dict_size; 71 71 - code_bits := 9; 72 72 - prev_string := "" 73 73 - in 109 109 + decode_loop (); 110 110 + Ok !out_pos 111 111 + with 112 112 + | Exit -> Error Unexpected_eof 113 113 + | Failure msg when msg = "overflow" -> Error Buffer_overflow 114 114 + | Failure msg when msg = "invalid" -> Error (Invalid_code 0) 115 115 + | _ -> Error (Invalid_code 0) 74 116 75 75 - let rec decode_loop () = 76 76 - let code = read_bits_lsb reader !code_bits in 77 77 - if code = eof_code then () 78 78 - else if code = clear_code then begin 79 79 - reset_dict (); 80 80 - decode_loop () 81 81 - end 82 82 - else begin 83 83 - let current_string = 84 84 - if code < !dict_size then dict.(code) 85 85 - else if code = !dict_size then 86 86 - !prev_string ^ String.make 1 !prev_string.[0] 87 87 - else 88 88 - raise 89 89 - (Failure 90 90 - (Printf.sprintf "invalid code %d >= %d" code !dict_size)) 91 91 - in 92 92 - Buffer.add_string output current_string; 93 93 - if !prev_string <> "" then 94 94 - add_to_dict (!prev_string ^ String.make 1 current_string.[0]); 95 95 - prev_string := current_string; 96 96 - decode_loop () 97 97 - end 98 98 - in 117 117 + let decompress_cstruct src = 118 118 + let estimated_size = max (Cstruct.length src * 4) 4096 in 119 119 + let dst = Cstruct.create estimated_size in 120 120 + match decompress_to_buffer ~src ~dst with 121 121 + | Ok len -> Ok (Cstruct.sub dst 0 len) 122 122 + | Error Buffer_overflow -> ( 123 123 + let larger = Cstruct.create (estimated_size * 4) in 124 124 + match decompress_to_buffer ~src ~dst:larger with 125 125 + | Ok len -> Ok (Cstruct.sub larger 0 len) 126 126 + | Error e -> Error e) 127 127 + | Error e -> Error e 99 128 100 100 - decode_loop (); 101 101 - Ok (Buffer.contents output) 102 102 - with 103 103 - | Failure msg when msg = "eof" -> Error Unexpected_eof 104 104 - | Failure msg 105 105 - when String.length msg > 12 && String.sub msg 0 12 = "invalid code" -> 106 106 - Error (Invalid_code 0) 107 107 - | _ -> Error (Invalid_code 0) 129 129 + let decompress ?(order = LSB) ?(lit_width = 8) data = 130 130 + if order <> LSB then Error (Invalid_code 0) 131 131 + else if lit_width <> 8 then Error (Invalid_code 0) 132 132 + else 133 133 + let src = Cstruct.of_string data in 134 134 + match decompress_cstruct src with 135 135 + | Ok cs -> Ok (Cstruct.to_string cs) 136 136 + | Error e -> Error e 108 137 109 138 let decompress_lsb8 data = decompress ~order:LSB ~lit_width:8 data

+2

lib/lzw.mli

··· 2 2 type error = Invalid_code of int | Unexpected_eof | Buffer_overflow 3 3 4 4 val error_to_string : error -> string 5 5 + val decompress_to_buffer : src:Cstruct.t -> dst:Cstruct.t -> (int, error) result 6 6 + val decompress_cstruct : Cstruct.t -> (Cstruct.t, error) result 5 7 6 8 val decompress : 7 9 ?order:order -> ?lit_width:int -> string -> (string, error) result

+131 -97

lib/protocol.ml

··· 11 11 probe_index : int Kcas.Loc.t; 12 12 send_pool : Buffer_pool.t; 13 13 recv_pool : Buffer_pool.t; 14 14 + tcp_recv_pool : Buffer_pool.t; 15 15 + tcp_decompress_pool : Buffer_pool.t; 14 16 udp_sock : [ `Generic ] Eio.Net.datagram_socket_ty Eio.Resource.t; 15 17 tcp_listener : [ `Generic ] Eio.Net.listening_socket_ty Eio.Resource.t; 16 18 event_stream : node_event Eio.Stream.t; ··· 92 94 Protocol_pure.retransmit_limit t.config 93 95 ~node_count:(Membership.count t.members) 94 96 in 95 95 - Dissemination.enqueue t.broadcast_queue msg ~transmits ~created:(now_mtime t); 97 97 + Dissemination.enqueue t.broadcast_queue msg ~transmits ~created:(now_mtime t) 98 98 + ~limit:t.config.max_gossip_queue_depth; 96 99 Dissemination.invalidate t.broadcast_queue 97 100 ~invalidates:Protocol_pure.invalidates msg 98 101 ··· 180 183 let handlers = 181 184 Kcas.Xt.commit { tx = (fun ~xt -> Kcas.Xt.get ~xt t.user_handlers) } 182 185 in 183 183 - match Membership.find t.members origin with 184 184 - | None -> () 185 185 - | Some member -> 186 186 - let node = Membership.Member.node member in 187 187 - List.iter (fun h -> h node topic payload) handlers) 186 186 + if List.length handlers = 0 then () 187 187 + else 188 188 + match Membership.find t.members origin with 189 189 + | None -> () 190 190 + | Some member -> 191 191 + let node = Membership.Member.node member in 192 192 + List.iter (fun h -> h node topic payload) handlers) 188 193 | _ -> () 189 194 190 195 let handle_message t ~src (msg : protocol_msg) = ··· 369 374 else None 370 375 | _ -> None 371 376 377 377 + let decompress_payload_cstruct ~src ~dst = 378 378 + match Codec.decode_compress_from_cstruct src with 379 379 + | Error _ -> None 380 380 + | Ok (algo, compressed) -> 381 381 + if algo = 0 then 382 382 + match Lzw.decompress_to_buffer ~src:compressed ~dst with 383 383 + | Ok len -> Some len 384 384 + | Error _ -> None 385 385 + else None 386 386 + 372 387 let handle_tcp_connection t flow = 373 373 - let buf = Cstruct.create 65536 in 374 374 - match read_exact flow buf 1 with 375 375 - | Error _ -> () 376 376 - | Ok () -> ( 377 377 - let msg_type_byte = Cstruct.get_uint8 buf 0 in 378 378 - let get_push_pull_payload () = 379 379 - let n = read_available flow (Cstruct.shift buf 1) in 380 380 - if n > 0 then Some (Cstruct.sub buf 1 n) else None 381 381 - in 382 382 - let payload_opt = 383 383 - if msg_type_byte = Types.Wire.message_type_to_int Types.Wire.Encrypt_msg 384 384 - then 385 385 - match get_push_pull_payload () with 386 386 - | Some encrypted -> ( 387 387 - match Crypto.decrypt ~key:t.cipher_key encrypted with 388 388 - | Ok decrypted -> Some decrypted 389 389 - | Error _ -> None) 390 390 - | None -> None 391 391 - else if 392 392 - msg_type_byte = Types.Wire.message_type_to_int Types.Wire.Compress_msg 393 393 - then 394 394 - match get_push_pull_payload () with 395 395 - | Some compressed -> ( 396 396 - let data = Cstruct.to_string compressed in 397 397 - match decompress_payload data with 398 398 - | Some decompressed -> 399 399 - if String.length decompressed > 0 then 400 400 - let inner_type = Char.code decompressed.[0] in 401 401 - if 402 402 - inner_type 403 403 - = Types.Wire.message_type_to_int Types.Wire.Push_pull_msg 404 404 - then 405 405 - Some 406 406 - (Cstruct.of_string 407 407 - (String.sub decompressed 1 408 408 - (String.length decompressed - 1))) 409 409 - else None 410 410 - else None 411 411 - | None -> None) 412 412 - | None -> None 413 413 - else if 414 414 - msg_type_byte 415 415 - = Types.Wire.message_type_to_int Types.Wire.Has_label_msg 416 416 - then 388 388 + Buffer_pool.with_buffer t.tcp_recv_pool (fun buf -> 389 389 + Buffer_pool.with_buffer t.tcp_decompress_pool (fun decomp_buf -> 417 390 match read_exact flow buf 1 with 418 418 - | Error _ -> None 419 419 - | Ok () -> 420 420 - let label_len = Cstruct.get_uint8 buf 0 in 421 421 - if label_len > 0 then 422 422 - match read_exact flow buf label_len with 423 423 - | Error _ -> None 424 424 - | Ok () -> ( 425 425 - match read_exact flow buf 1 with 426 426 - | Error _ -> None 427 427 - | Ok () -> 428 428 - let inner_type = Cstruct.get_uint8 buf 0 in 429 429 - if 430 430 - inner_type 431 431 - = Types.Wire.message_type_to_int 432 432 - Types.Wire.Push_pull_msg 433 433 - then get_push_pull_payload () 434 434 - else None) 435 435 - else None 436 436 - else if 437 437 - msg_type_byte 438 438 - = Types.Wire.message_type_to_int Types.Wire.Push_pull_msg 439 439 - then get_push_pull_payload () 440 440 - else None 441 441 - in 442 442 - match payload_opt with 443 443 - | None -> () 444 444 - | Some payload -> ( 445 445 - let data = Cstruct.to_string payload in 446 446 - match Codec.decode_push_pull_msg data with 447 391 | Error _ -> () 448 448 - | Ok (header, nodes, _user_state) -> ( 449 449 - merge_remote_state t nodes ~is_join:header.pp_join; 450 450 - let resp_header, resp_nodes = 451 451 - build_local_state t ~is_join:false 452 452 - in 453 453 - let response = 454 454 - Codec.encode_push_pull_msg ~header:resp_header ~nodes:resp_nodes 455 455 - ~user_state:"" 392 392 + | Ok () -> ( 393 393 + let msg_type_byte = Cstruct.get_uint8 buf 0 in 394 394 + let get_push_pull_payload () = 395 395 + let n = read_available flow (Cstruct.shift buf 1) in 396 396 + if n > 0 then Some (Cstruct.sub buf 1 n) else None 456 397 in 457 457 - let resp_buf = 458 458 - if t.config.encryption_enabled then 459 459 - let plain = Cstruct.of_string response in 460 460 - let encrypted = 461 461 - Crypto.encrypt ~key:t.cipher_key ~random:t.secure_random 462 462 - plain 463 463 - in 464 464 - encrypted 465 465 - else Cstruct.of_string response 398 398 + let payload_opt = 399 399 + if 400 400 + msg_type_byte 401 401 + = Types.Wire.message_type_to_int Types.Wire.Encrypt_msg 402 402 + then 403 403 + match get_push_pull_payload () with 404 404 + | Some encrypted -> ( 405 405 + match Crypto.decrypt ~key:t.cipher_key encrypted with 406 406 + | Ok decrypted -> Some decrypted 407 407 + | Error _ -> None) 408 408 + | None -> None 409 409 + else if 410 410 + msg_type_byte 411 411 + = Types.Wire.message_type_to_int Types.Wire.Compress_msg 412 412 + then 413 413 + match get_push_pull_payload () with 414 414 + | Some compressed -> ( 415 415 + match 416 416 + decompress_payload_cstruct ~src:compressed 417 417 + ~dst:decomp_buf 418 418 + with 419 419 + | Some len -> 420 420 + if len > 0 then 421 421 + let inner_type = Cstruct.get_uint8 decomp_buf 0 in 422 422 + if 423 423 + inner_type 424 424 + = Types.Wire.message_type_to_int 425 425 + Types.Wire.Push_pull_msg 426 426 + then Some (Cstruct.sub decomp_buf 1 (len - 1)) 427 427 + else None 428 428 + else None 429 429 + | None -> None) 430 430 + | None -> None 431 431 + else if 432 432 + msg_type_byte 433 433 + = Types.Wire.message_type_to_int Types.Wire.Has_label_msg 434 434 + then 435 435 + match read_exact flow buf 1 with 436 436 + | Error _ -> None 437 437 + | Ok () -> 438 438 + let label_len = Cstruct.get_uint8 buf 0 in 439 439 + if label_len > 0 then 440 440 + match read_exact flow buf label_len with 441 441 + | Error _ -> None 442 442 + | Ok () -> ( 443 443 + match read_exact flow buf 1 with 444 444 + | Error _ -> None 445 445 + | Ok () -> 446 446 + let inner_type = Cstruct.get_uint8 buf 0 in 447 447 + if 448 448 + inner_type 449 449 + = Types.Wire.message_type_to_int 450 450 + Types.Wire.Push_pull_msg 451 451 + then get_push_pull_payload () 452 452 + else None) 453 453 + else None 454 454 + else if 455 455 + msg_type_byte 456 456 + = Types.Wire.message_type_to_int Types.Wire.Push_pull_msg 457 457 + then get_push_pull_payload () 458 458 + else None 466 459 in 467 467 - try Eio.Flow.write flow [ resp_buf ] with _ -> ()))) 460 460 + match payload_opt with 461 461 + | None -> () 462 462 + | Some payload -> ( 463 463 + match Codec.decode_push_pull_msg_cstruct payload with 464 464 + | Error _ -> () 465 465 + | Ok (header, nodes, _user_state) -> ( 466 466 + merge_remote_state t nodes ~is_join:header.pp_join; 467 467 + let resp_header, resp_nodes = 468 468 + build_local_state t ~is_join:false 469 469 + in 470 470 + let response = 471 471 + Codec.encode_push_pull_msg ~header:resp_header 472 472 + ~nodes:resp_nodes ~user_state:"" 473 473 + in 474 474 + let resp_buf = 475 475 + if t.config.encryption_enabled then 476 476 + let plain = Cstruct.of_string response in 477 477 + let encrypted = 478 478 + Crypto.encrypt ~key:t.cipher_key 479 479 + ~random:t.secure_random plain 480 480 + in 481 481 + encrypted 482 482 + else Cstruct.of_string response 483 483 + in 484 484 + try Eio.Flow.write flow [ resp_buf ] with _ -> ()))))) 468 485 469 486 let run_tcp_listener t = 470 487 while not (is_shutdown t) do ··· 589 606 recv_pool = 590 607 Buffer_pool.create ~size:config.udp_buffer_size 591 608 ~count:config.recv_buffer_count; 609 609 + tcp_recv_pool = Buffer_pool.create ~size:65536 ~count:4; 610 610 + tcp_decompress_pool = Buffer_pool.create ~size:131072 ~count:4; 592 611 udp_sock; 593 612 tcp_listener; 594 613 event_stream = Eio.Stream.create 100; ··· 652 671 let broadcast t ~topic ~payload = 653 672 let msg = User_msg { topic; payload; origin = t.self.id } in 654 673 enqueue_broadcast t msg 674 674 + 675 675 + let send_direct t ~target ~topic ~payload = 676 676 + match Membership.find t.members target with 677 677 + | None -> Error `Unknown_node 678 678 + | Some member -> 679 679 + let node = Membership.Member.node member in 680 680 + let msg = User_msg { topic; payload; origin = t.self.id } in 681 681 + let packet = make_packet t ~primary:msg ~piggyback:[] in 682 682 + send_packet t ~dst:node.addr packet; 683 683 + Ok () 684 684 + 685 685 + let send_to_addr t ~addr ~topic ~payload = 686 686 + let msg = User_msg { topic; payload; origin = t.self.id } in 687 687 + let packet = make_packet t ~primary:msg ~piggyback:[] in 688 688 + send_packet t ~dst:addr packet 655 689 656 690 let on_message t handler = 657 691 Kcas.Xt.commit

+15 -3

lib/swim.ml

··· 49 49 | Ok protocol -> Ok { protocol; sw } 50 50 51 51 let start t = 52 52 - Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_protocol t.protocol); 53 53 - Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_udp_receiver t.protocol); 54 54 - Eio.Fiber.fork ~sw:t.sw (fun () -> Protocol.run_tcp_listener t.protocol) 52 52 + Eio.Fiber.fork_daemon ~sw:t.sw (fun () -> 53 53 + Protocol.run_protocol t.protocol; 54 54 + `Stop_daemon); 55 55 + Eio.Fiber.fork_daemon ~sw:t.sw (fun () -> 56 56 + Protocol.run_udp_receiver t.protocol; 57 57 + `Stop_daemon); 58 58 + Eio.Fiber.fork_daemon ~sw:t.sw (fun () -> 59 59 + Protocol.run_tcp_listener t.protocol; 60 60 + `Stop_daemon) 55 61 56 62 let shutdown t = Protocol.shutdown t.protocol 57 63 let local_node t = Protocol.local_node t.protocol ··· 77 83 78 84 let broadcast t ~topic ~payload = 79 85 Protocol.broadcast t.protocol ~topic ~payload 86 86 + 87 87 + let send t ~target ~topic ~payload = 88 88 + Protocol.send_direct t.protocol ~target ~topic ~payload 89 89 + 90 90 + let send_to_addr t ~addr ~topic ~payload = 91 91 + Protocol.send_to_addr t.protocol ~addr ~topic ~payload 80 92 81 93 let on_message t handler = Protocol.on_message t.protocol handler 82 94

+71 -3

lib/types.ml

··· 116 116 encryption_enabled : bool; 117 117 gossip_verify_incoming : bool; 118 118 gossip_verify_outgoing : bool; 119 119 + max_gossip_queue_depth : int; 119 120 } 120 121 121 122 let default_config = ··· 139 140 encryption_enabled = false; 140 141 gossip_verify_incoming = true; 141 142 gossip_verify_outgoing = true; 143 143 + max_gossip_queue_depth = 5000; 142 144 } 143 145 144 146 type 'a env = { ··· 401 403 node = node_id_to_string node; 402 404 from = node_id_to_string declarator; 403 405 } 404 404 - | User_msg { topic = _; payload; origin = _ } -> Wire.User_data payload 406 406 + | User_msg { topic; payload; origin } -> 407 407 + let origin_str = node_id_to_string origin in 408 408 + let topic_len = String.length topic in 409 409 + let origin_len = String.length origin_str in 410 410 + let encoded = 411 411 + String.concat "" 412 412 + [ 413 413 + string_of_int topic_len; 414 414 + ":"; 415 415 + topic; 416 416 + string_of_int origin_len; 417 417 + ":"; 418 418 + origin_str; 419 419 + payload; 420 420 + ] 421 421 + in 422 422 + Wire.User_data encoded 405 423 406 424 let msg_of_wire ~default_port (wmsg : Wire.protocol_msg) : protocol_msg option = 407 425 match wmsg with ··· 475 493 incarnation = incarnation_of_int incarnation; 476 494 declarator = node_id_of_string from; 477 495 }) 478 478 - | Wire.User_data payload -> 479 479 - Some (User_msg { topic = ""; payload; origin = node_id_of_string "" }) 496 496 + | Wire.User_data encoded -> ( 497 497 + let parse_length s start = 498 498 + let rec find_colon i = 499 499 + if i >= String.length s then None 500 500 + else if s.[i] = ':' then Some i 501 501 + else find_colon (i + 1) 502 502 + in 503 503 + match find_colon start with 504 504 + | None -> None 505 505 + | Some colon_pos -> ( 506 506 + let len_str = String.sub s start (colon_pos - start) in 507 507 + match int_of_string_opt len_str with 508 508 + | None -> None 509 509 + | Some len -> Some (len, colon_pos + 1)) 510 510 + in 511 511 + match parse_length encoded 0 with 512 512 + | None -> 513 513 + Some 514 514 + (User_msg 515 515 + { topic = ""; payload = encoded; origin = node_id_of_string "" }) 516 516 + | Some (topic_len, topic_start) -> ( 517 517 + if topic_start + topic_len > String.length encoded then 518 518 + Some 519 519 + (User_msg 520 520 + { 521 521 + topic = ""; 522 522 + payload = encoded; 523 523 + origin = node_id_of_string ""; 524 524 + }) 525 525 + else 526 526 + let topic = String.sub encoded topic_start topic_len in 527 527 + let origin_start = topic_start + topic_len in 528 528 + match parse_length encoded origin_start with 529 529 + | None -> 530 530 + Some 531 531 + (User_msg 532 532 + { topic; payload = ""; origin = node_id_of_string "" }) 533 533 + | Some (origin_len, payload_start) -> 534 534 + if payload_start + origin_len > String.length encoded then 535 535 + Some 536 536 + (User_msg 537 537 + { topic; payload = ""; origin = node_id_of_string "" }) 538 538 + else 539 539 + let origin = String.sub encoded payload_start origin_len in 540 540 + let data_start = payload_start + origin_len in 541 541 + let payload = 542 542 + String.sub encoded data_start 543 543 + (String.length encoded - data_start) 544 544 + in 545 545 + Some 546 546 + (User_msg 547 547 + { topic; payload; origin = node_id_of_string origin }))) 480 548 | Wire.Nack _ -> None 481 549 | Wire.Compound _ -> None 482 550 | Wire.Compressed _ -> None

+1

lib/types.mli

··· 92 92 encryption_enabled : bool; 93 93 gossip_verify_incoming : bool; 94 94 gossip_verify_outgoing : bool; 95 95 + max_gossip_queue_depth : int; 95 96 } 96 97 97 98 val default_config : config

+19 -17

swim.opam

··· 1 1 # This file is generated by dune, edit dune-project instead 2 2 opam-version: "2.0" 3 3 + version: "0.1.0" 3 4 synopsis: 4 5 "SWIM protocol library for cluster membership and failure detection" 5 6 description: 6 7 "Production-ready SWIM (Scalable Weakly-consistent Infection-style Process Group Membership) protocol library in OCaml 5 for cluster membership, failure detection, and lightweight pub/sub messaging. Features lock-free coordination via kcas, zero-copy buffer management, and AES-256-GCM encryption." 7 7 - maintainer: ["Guillermo Diaz-Romero <guillermo.diaz@gmail.com>"] 8 8 - authors: ["Guillermo Diaz-Romero <guillermo.diaz@gmail.com>"] 9 9 - license: "MIT" 8 8 + maintainer: ["Gabriel Diaz"] 9 9 + authors: ["Gabriel Diaz"] 10 10 + license: "ISC" 10 11 tags: [ 11 12 "swim" "cluster" "membership" "gossip" "failure detection" "ocaml5" "eio" 12 13 ] 13 13 - homepage: "https://github.com/gdiazlo/swim" 14 14 - doc: "https://github.com/gdiazlo/swim" 15 15 - bug-reports: "https://github.com/gdiazlo/swim/issues" 14 14 + homepage: "https://tangled.org/gdiazlo.tngl.sh/swim" 15 15 + doc: "https://tangled.org/gdiazlo.tngl.sh/swim" 16 16 + bug-reports: "https://tangled.org/gdiazlo.tngl.sh/swim/issues" 16 17 depends: [ 17 18 "ocaml" {>= "5.1"} 18 19 "dune" {>= "3.20" & >= "3.20"} 19 19 - "eio" {>= "1.0"} 20 20 - "eio_main" {>= "1.0"} 20 20 + "eio" {>= "1.3"} 21 21 "kcas" {>= "0.7"} 22 22 "kcas_data" {>= "0.7"} 23 23 - "mirage-crypto" {>= "1.0"} 24 24 - "mirage-crypto-rng" {>= "1.0"} 25 25 - "cstruct" {>= "6.0"} 26 26 - "mtime" {>= "2.0"} 23 23 + "mirage-crypto" {>= "2.0"} 24 24 + "mirage-crypto-rng" {>= "2.0"} 25 25 + "cstruct" {>= "6.2"} 26 26 + "mtime" {>= "2.1"} 27 27 "msgpck" {>= "1.7"} 28 28 - "qcheck" {>= "0.21"} 29 29 - "qcheck-alcotest" {>= "0.21"} 30 30 - "alcotest" {>= "1.7"} 31 31 - "logs" {>= "0.7"} 28 28 + "logs" {>= "0.10"} 29 29 + "fmt" {>= "0.11"} 30 30 + "eio_main" {>= "1.3" & with-test} 31 31 + "qcheck" {>= "0.21" & with-test} 32 32 + "qcheck-alcotest" {>= "0.21" & with-test} 33 33 + "alcotest" {>= "1.7" & with-test} 32 34 "odoc" {with-doc} 33 35 ] 34 36 build: [ ··· 45 47 "@doc" {with-doc} 46 48 ] 47 49 ] 48 48 - dev-repo: "git+https://github.com/gdiazlo/swim.git" 50 50 + dev-repo: "git+https://tangled.org/gdiazlo.tngl.sh/swim" 49 51 x-maintenance-intent: ["(latest)"]

+3 -1

test/generators.ml

··· 198 198 and+ label = oneof [ return ""; gen_topic ] 199 199 and+ encryption_enabled = bool 200 200 and+ gossip_verify_incoming = bool 201 201 - and+ gossip_verify_outgoing = bool in 201 201 + and+ gossip_verify_outgoing = bool 202 202 + and+ max_gossip_queue_depth = int_range 10 10000 in 202 203 { 203 204 bind_addr; 204 205 bind_port; ··· 219 220 encryption_enabled; 220 221 gossip_verify_incoming; 221 222 gossip_verify_outgoing; 223 223 + max_gossip_queue_depth; 222 224 } 223 225 224 226 let gen_decode_error : decode_error QCheck.Gen.t =

+21

test/scripts/test_interop.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + REPO_ROOT="$SCRIPT_DIR/../.." 6 6 + 7 7 + echo "Starting Go memberlist server WITHOUT encryption..." 8 8 + cd "$REPO_ROOT/interop" 9 9 + ./memberlist-server -name go-node -port 7946 & 10 10 + GO_PID=$! 11 11 + sleep 2 12 12 + 13 13 + echo "Starting OCaml SWIM client..." 14 14 + cd "$REPO_ROOT" 15 15 + timeout 25 ./_build/default/bin/interop_test.exe || true 16 16 + 17 17 + echo "Killing Go server..." 18 18 + kill $GO_PID 2>/dev/null || true 19 19 + wait $GO_PID 2>/dev/null || true 20 20 + 21 21 + echo "Done"

+24

test/scripts/test_interop_encrypted.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + REPO_ROOT="$SCRIPT_DIR/../.." 6 6 + 7 7 + # Test key: 16 bytes (0x00-0x0f) in hex 8 8 + TEST_KEY="000102030405060708090a0b0c0d0e0f" 9 9 + 10 10 + echo "Starting Go memberlist server WITH encryption..." 11 11 + cd "$REPO_ROOT/interop" 12 12 + ./memberlist-server -name go-node -port 7946 -key "$TEST_KEY" & 13 13 + GO_PID=$! 14 14 + sleep 2 15 15 + 16 16 + echo "Starting OCaml SWIM client WITH encryption..." 17 17 + cd "$REPO_ROOT" 18 18 + timeout 25 ./_build/default/bin/interop_test.exe --encrypt || true 19 19 + 20 20 + echo "Killing Go server..." 21 21 + kill $GO_PID 2>/dev/null || true 22 22 + wait $GO_PID 2>/dev/null || true 23 23 + 24 24 + echo "Done"

+29

test/scripts/test_interop_go_joins.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + REPO_ROOT="$SCRIPT_DIR/../.." 6 6 + 7 7 + # Test where Go node joins to OCaml node (reverse direction) 8 8 + 9 9 + echo "Starting OCaml SWIM server..." 10 10 + cd "$REPO_ROOT" 11 11 + timeout 25 ./_build/default/bin/interop_test.exe & 12 12 + OCAML_PID=$! 13 13 + sleep 2 14 14 + 15 15 + echo "Starting Go memberlist and joining to OCaml..." 16 16 + cd "$REPO_ROOT/interop" 17 17 + ./memberlist-server -name go-node -port 7946 -join "127.0.0.1:7947" & 18 18 + GO_PID=$! 19 19 + 20 20 + # Let them communicate for a while 21 21 + sleep 15 22 22 + 23 23 + echo "Killing processes..." 24 24 + kill $GO_PID 2>/dev/null || true 25 25 + kill $OCAML_PID 2>/dev/null || true 26 26 + wait $GO_PID 2>/dev/null || true 27 27 + wait $OCAML_PID 2>/dev/null || true 28 28 + 29 29 + echo "Done"

+31

test/scripts/test_interop_udp_only.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + REPO_ROOT="$SCRIPT_DIR/../.." 6 6 + 7 7 + # Test UDP-only communication (no TCP join) 8 8 + # Both nodes start independently, OCaml adds Go to its membership 9 9 + # They should then be able to gossip via UDP 10 10 + 11 11 + echo "Starting Go memberlist server (no join)..." 12 12 + cd "$REPO_ROOT/interop" 13 13 + ./memberlist-server -name go-node -port 7946 & 14 14 + GO_PID=$! 15 15 + sleep 2 16 16 + 17 17 + echo "Starting OCaml SWIM client (adds Go node manually)..." 18 18 + cd "$REPO_ROOT" 19 19 + timeout 20 ./_build/default/bin/interop_test.exe & 20 20 + OCAML_PID=$! 21 21 + 22 22 + # Let them communicate 23 23 + sleep 15 24 24 + 25 25 + echo "Killing processes..." 26 26 + kill $GO_PID 2>/dev/null || true 27 27 + kill $OCAML_PID 2>/dev/null || true 28 28 + wait $GO_PID 2>/dev/null || true 29 29 + wait $OCAML_PID 2>/dev/null || true 30 30 + 31 31 + echo "Done"

-18

test_interop.sh

··· 1 1 - #!/bin/bash 2 2 - set -e 3 3 - 4 4 - echo "Starting Go memberlist server WITHOUT encryption..." 5 5 - cd /home/gdiazlo/data/src/swim/interop 6 6 - ./memberlist-server -name go-node -port 7946 & 7 7 - GO_PID=$! 8 8 - sleep 2 9 9 - 10 10 - echo "Starting OCaml SWIM client..." 11 11 - cd /home/gdiazlo/data/src/swim 12 12 - timeout 25 ./_build/default/bin/interop_test.exe || true 13 13 - 14 14 - echo "Killing Go server..." 15 15 - kill $GO_PID 2>/dev/null || true 16 16 - wait $GO_PID 2>/dev/null || true 17 17 - 18 18 - echo "Done"

-21

test_interop_encrypted.sh

··· 1 1 - #!/bin/bash 2 2 - set -e 3 3 - 4 4 - # Test key: 16 bytes (0x00-0x0f) in hex 5 5 - TEST_KEY="000102030405060708090a0b0c0d0e0f" 6 6 - 7 7 - echo "Starting Go memberlist server WITH encryption..." 8 8 - cd /home/gdiazlo/data/src/swim/interop 9 9 - ./memberlist-server -name go-node -port 7946 -key "$TEST_KEY" & 10 10 - GO_PID=$! 11 11 - sleep 2 12 12 - 13 13 - echo "Starting OCaml SWIM client WITH encryption..." 14 14 - cd /home/gdiazlo/data/src/swim 15 15 - timeout 25 ./_build/default/bin/interop_test.exe --encrypt || true 16 16 - 17 17 - echo "Killing Go server..." 18 18 - kill $GO_PID 2>/dev/null || true 19 19 - wait $GO_PID 2>/dev/null || true 20 20 - 21 21 - echo "Done"

-26

test_interop_go_joins.sh

··· 1 1 - #!/bin/bash 2 2 - set -e 3 3 - 4 4 - # Test where Go node joins to OCaml node (reverse direction) 5 5 - 6 6 - echo "Starting OCaml SWIM server..." 7 7 - cd /home/gdiazlo/data/src/swim 8 8 - timeout 25 ./_build/default/bin/interop_test.exe & 9 9 - OCAML_PID=$! 10 10 - sleep 2 11 11 - 12 12 - echo "Starting Go memberlist and joining to OCaml..." 13 13 - cd /home/gdiazlo/data/src/swim/interop 14 14 - ./memberlist-server -name go-node -port 7946 -join "127.0.0.1:7947" & 15 15 - GO_PID=$! 16 16 - 17 17 - # Let them communicate for a while 18 18 - sleep 15 19 19 - 20 20 - echo "Killing processes..." 21 21 - kill $GO_PID 2>/dev/null || true 22 22 - kill $OCAML_PID 2>/dev/null || true 23 23 - wait $GO_PID 2>/dev/null || true 24 24 - wait $OCAML_PID 2>/dev/null || true 25 25 - 26 26 - echo "Done"

-28

test_interop_udp_only.sh

··· 1 1 - #!/bin/bash 2 2 - set -e 3 3 - 4 4 - # Test UDP-only communication (no TCP join) 5 5 - # Both nodes start independently, OCaml adds Go to its membership 6 6 - # They should then be able to gossip via UDP 7 7 - 8 8 - echo "Starting Go memberlist server (no join)..." 9 9 - cd /home/gdiazlo/data/src/swim/interop 10 10 - ./memberlist-server -name go-node -port 7946 & 11 11 - GO_PID=$! 12 12 - sleep 2 13 13 - 14 14 - echo "Starting OCaml SWIM client (adds Go node manually)..." 15 15 - cd /home/gdiazlo/data/src/swim 16 16 - timeout 20 ./_build/default/bin/interop_test.exe & 17 17 - OCAML_PID=$! 18 18 - 19 19 - # Let them communicate 20 20 - sleep 15 21 21 - 22 22 - echo "Killing processes..." 23 23 - kill $GO_PID 2>/dev/null || true 24 24 - kill $OCAML_PID 2>/dev/null || true 25 25 - wait $GO_PID 2>/dev/null || true 26 26 - wait $OCAML_PID 2>/dev/null || true 27 27 - 28 28 - echo "Done"