lmcache-cli 0.4.8.dev31__py3-none-any.whl → 0.4.8.dev42__py3-none-any.whl

lmcache/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.8.dev31'
-__version_tuple__ = version_tuple = (0, 4, 8, 'dev31')
+__version__ = version = '0.4.8.dev42'
+__version_tuple__ = version_tuple = (0, 4, 8, 'dev42')
 
-__commit_id__ = commit_id = 'g71d2c23f4'
+__commit_id__ = commit_id = 'g9ffb104f3'

lmcache/cli/commands/tool/__init__.py

@@ -15,7 +15,7 @@ import sys
 
 # First Party
 from lmcache.cli.commands.base import BaseCommand
-from lmcache.cli.commands.tool import cache_simulator
+from lmcache.cli.commands.tool import cache_simulator, transfer_channel_benchmark
 
 
 class ToolCommand(BaseCommand):
@@ -46,9 +46,10 @@ class ToolCommand(BaseCommand):
         inner = parser.add_subparsers(
             dest="tool_name",
             required=True,
-            metavar="{cache-simulator}",
+            metavar="{cache-simulator,transfer-channel-benchmark}",
         )
         cache_simulator.register(inner)
+        transfer_channel_benchmark.register(inner)
 
     def execute(self, args: argparse.Namespace) -> None:
         """Dispatch is handled per-tool via parser.set_defaults(func=...).

lmcache/cli/commands/tool/transfer_channel_benchmark.py

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: Apache-2.0
+"""``lmcache tool transfer-channel-benchmark`` sub-subcommand wiring.
+
+Argument definitions and execution logic live in the benchmark module:
+
+* :func:`~lmcache.tools.transfer_channel_benchmark.benchmark.add_benchmark_arguments`
+* :func:`~lmcache.tools.transfer_channel_benchmark.benchmark.run_benchmark`
+"""
+
+# Standard
+import argparse
+import sys
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``transfer-channel-benchmark`` sub-subcommand.
+
+    Only the torch-free ``config`` module is imported here, so registering this
+    tool (which happens on every ``lmcache`` invocation) does not require torch
+    or the distributed runtime. Those are imported in ``execute``.
+
+    Args:
+        subparsers: The subparsers action from the ``lmcache tool`` parser.
+    """
+    # First Party
+    from lmcache.tools.transfer_channel_benchmark.config import (
+        add_benchmark_arguments,
+    )
+
+    parser = subparsers.add_parser(
+        "transfer-channel-benchmark",
+        help="Benchmark transfer channel read throughput (server/client).",
+        description=(
+            "Throughput benchmark for the LMCache transfer channel. Run one "
+            "process with --role server and another with --role client."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    add_benchmark_arguments(parser)
+    parser.set_defaults(func=execute)
+
+
+def execute(args: argparse.Namespace) -> None:
+    """Run the benchmark and exit non-zero on failure.
+
+    Args:
+        args: Parsed CLI arguments.
+    """
+    # First Party
+    from lmcache.tools.transfer_channel_benchmark.benchmark import run_benchmark
+
+    if not run_benchmark(args):
+        sys.exit(1)

lmcache/tools/transfer_channel_benchmark/README.md

@@ -0,0 +1,128 @@
+# Transfer Channel Throughput Benchmark
+
+Measures read throughput (GB/s) of the LMCache **transfer channel**
+(`lmcache/v1/distributed/transfer_channel/`) for batched peer-to-peer reads.
+
+Unlike a raw-tensor microbenchmark, this tool uses LMCache's `L1MemoryManager`
+to initialize the registered memory region and to **allocate the transferred
+objects** on both sides, so it exercises the same memory path production uses.
+
+## How it works
+
+The benchmark runs as **two separate processes**:
+
+- **server** — uses an `L1MemoryManager` to allocate a registered L1 buffer and
+  a pool of source memory objects, registers the buffer with the transfer
+  channel, and publishes the source object catalog (`offset`/`size` per object)
+  over a small ZMQ side-channel.
+- **client** — fetches the catalog, allocates its own destination objects via an
+  `L1MemoryManager`, connects the transfer channel, and repeatedly reads a random
+  `--num-objects` subset of the source objects, then reports throughput.
+
+A side-channel is needed because the transfer channel handshake only exchanges
+the whole-buffer registration, not per-object offsets.
+
+> Only the `nixl` transfer channel type is registered today. The tool is generic
+> over `--transfer-channel-type`; an unknown type raises a clear error.
+
+## Usage
+
+Run via the module or the `lmcache` CLI. Start the server first.
+
+### `python -m`
+
+```bash
+# terminal 1 — server
+python -m lmcache.tools.transfer_channel_benchmark \
+  --role server --transfer-channel-type nixl \
+  --url 0.0.0.0:7600 --control-url 0.0.0.0:7610 \
+  --buffer-size 2GB --page-size 512KB --object-size 10MB
+
+# terminal 2 — client
+python -m lmcache.tools.transfer_channel_benchmark \
+  --role client --transfer-channel-type nixl \
+  --url 127.0.0.1:7600 --control-url 127.0.0.1:7610 \
+  --listen-url 0.0.0.0:7601 \
+  --page-size 512KB --object-size 10MB \
+  --num-objects 10 --iters 3 --warmup 1
+```
+
+### `lmcache tool`
+
+```bash
+lmcache tool transfer-channel-benchmark --role server  --url 0.0.0.0:7600 \
+  --control-url 0.0.0.0:7610 --buffer-size 2GB --object-size 10MB
+lmcache tool transfer-channel-benchmark --role client --url 127.0.0.1:7600 \
+  --control-url 127.0.0.1:7610 --object-size 10MB --num-objects 10
+```
+
+The server always writes a deterministic per-object byte pattern (object index
+mod 256) into its source objects, so adding `--verify` on the **client** checks
+the transferred bytes against that pattern (no `--verify` needed on the server).
+
+## Key options
+
+| Option | Role | Meaning |
+| --- | --- | --- |
+| `--role {server,client}` | both | Which side to run (required). |
+| `--transfer-channel-type` | both | Implementation to benchmark (default `nixl`). |
+| `--nixl-backend` | both | nixl backend, e.g. `UCX` (nixl-specific). |
+| `--url` | both | Server binds its transfer-channel server here; client dials it. |
+| `--listen-url` | client | Client's own (mandatory) transfer-channel server bind. |
+| `--control-url` | both | Catalog side-channel: server binds, client connects. |
+| `--buffer-size` | server | Registered L1 source buffer size (e.g. `8GB`). |
+| `--page-size` | both | Page / alignment size; **must match** on both sides. |
+| `--object-size` | both | Per-object size; multiple of `--page-size`. |
+| `--num-objects` | client | Objects transferred per read. |
+| `--num-source-objects` | server | Source pool size (default `5 * --num-objects`). |
+| `--iters` / `--warmup` | client | Measured / warmup read iterations. |
+| `--seed` | client | RNG seed for the read subset. |
+| `--verify` | client | Verify transferred bytes against the server's known pattern. |
+| `--use-lazy` | both | Use the lazy L1 allocator (experimental for registration). |
+| `--server-timeout` | server | Seconds to serve catalog requests before exiting. |
+
+## Notes
+
+- `--page-size` must be identical on server and client (enforced via the catalog
+  handshake) so remote page-index math lines up.
+- With the default (non-lazy) allocator the whole `--buffer-size` is allocated up
+  front and may be CUDA-pinned; keep it within available host memory.
+- Requires a working transfer channel runtime (for `nixl`, a UCX backend).
+
+## Performance: NUMA placement
+
+On a multi-NUMA host with NICs spread across nodes (e.g. an 8-NIC, 2-socket
+box), run **both** the server and client under `numactl --interleave=all`:
+
+```bash
+numactl --interleave=all \
+python -m lmcache.tools.transfer_channel_benchmark --role server ...
+```
+
+Without it the registered buffer is allocated on a single NUMA node, so only the
+rails local to that node reach full bandwidth and the rest are throttled by the
+cross-socket link — roughly halving throughput. In testing on a 2-NUMA / 8-rail
+host this was the difference between **~110 GB/s** (no interleave) and
+**~210 GB/s** (`--interleave=all`), with everything else identical. Page size
+only matters in the small regime (descriptor-bound below ~64KB); from ~128KB up
+the transfer is bandwidth-bound and flat.
+
+## Troubleshooting
+
+- **Client hangs after "connected" or during connect, then raises
+  `TimeoutError` after ~60s.** The transfer-channel handshake could not reach the
+  server. Check that `--url`/`--control-url` on the client point at the *server's*
+  reachable address (a common mistake is a typo such as a trailing dot:
+  `10.0.0.5.:7600`), that the server is running, and that the ports are open
+  between hosts:
+  ```bash
+  nc -vz <server-host> 7600   # transfer channel
+  nc -vz <server-host> 7610   # catalog side-channel
+  ```
+  The handshake has a fixed 60s timeout, so a misconfiguration fails with a clear
+  error instead of hanging forever.
+- **`page_size`/`object_size` mismatch error.** The client validates these against
+  the server's catalog; pass the same `--page-size` and `--object-size` on both.
+- **Allocation `RuntimeError` on the server.** The source pool
+  (`--num-source-objects` × `--object-size`) must fit in `--buffer-size`; increase
+  the buffer or reduce the pool/object size.

lmcache/tools/transfer_channel_benchmark/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: Apache-2.0

lmcache/tools/transfer_channel_benchmark/__main__.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+"""``python -m lmcache.tools.transfer_channel_benchmark`` entry point."""
+
+# Standard
+import argparse
+import sys
+
+# First Party
+# Only the torch-free config module is imported eagerly so that `-h` works
+# without torch installed. The runtime (which needs torch) is imported after
+# arguments are parsed.
+from lmcache.tools.transfer_channel_benchmark.config import add_benchmark_arguments
+
+
+def main() -> int:
+    """Parse arguments and run the transfer channel benchmark.
+
+    Returns:
+        Process exit code (0 on success, 1 on failure).
+    """
+    parser = argparse.ArgumentParser(
+        prog="python -m lmcache.tools.transfer_channel_benchmark",
+        description="Throughput benchmark for the LMCache transfer channel.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    add_benchmark_arguments(parser)
+    args = parser.parse_args()
+
+    # Imported here (not at module load) so this entry point can show --help
+    # without requiring torch; importing it raises a clear error if torch is
+    # missing.
+    # First Party
+    from lmcache.tools.transfer_channel_benchmark.benchmark import run_benchmark
+
+    return 0 if run_benchmark(args) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lmcache/tools/transfer_channel_benchmark/benchmark.py

@@ -0,0 +1,385 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Core logic for the transfer channel throughput benchmark.
+
+A *server* process uses an :class:`L1MemoryManager` to initialize a registered
+L1 region, allocates a pool of source memory objects in it, registers the
+region with a transfer channel, and publishes the source object catalog
+(offset/size per object) over a small ZMQ side-channel.
+
+A *client* process fetches the catalog, allocates its own destination objects
+via an :class:`L1MemoryManager`, connects the transfer channel, and issues
+batched reads of a random subset of the source objects, reporting aggregate
+read throughput in GB/s.
+"""
+
+# Standard
+import argparse
+import json
+import random
+import time
+
+# Third Party
+import zmq
+
+# torch is an optional dependency for this benchmark tool. It (and the
+# distributed runtime imported below, which also needs torch) is imported here
+# rather than in config.py so the `lmcache` CLI can register this tool without
+# torch installed. Raise a clear, actionable error if it is missing.
+try:
+    # Third Party
+    import torch
+except ImportError as err:
+    raise ImportError(
+        "PyTorch is required to run the transfer channel benchmark but is not "
+        "installed. Install it (e.g. `pip install torch`) and retry."
+    ) from err
+
+# First Party
+from lmcache.logging import init_logger
+from lmcache.tools.transfer_channel_benchmark.config import (
+    BenchmarkConfig,
+    build_config,
+)
+from lmcache.v1.distributed.api import MemoryLayoutDesc
+from lmcache.v1.distributed.config import L1MemoryManagerConfig
+from lmcache.v1.distributed.error import L1Error
+from lmcache.v1.distributed.memory_manager import L1MemoryManager
+from lmcache.v1.distributed.transfer_channel import (
+    TransferChannelAddress,
+    delete_transfer_channel_context,
+    initialize_transfer_channel_context,
+)
+
+logger = init_logger(__name__)
+
+_CATALOG_REQUEST = b"catalog"
+_LARGE_LAZY_INIT = 20 * 1024**3
+_CLIENT_BUFFER_SLACK = 64 * 1024**2
+
+
+############################################################
+# Helpers
+############################################################
+def _zmq_endpoint(url: str) -> str:
+    """Return a ZMQ tcp endpoint for a ``host:port`` (or pass-through url)."""
+    return url if "://" in url else f"tcp://{url}"
+
+
+def _gbps(num_bytes: int, seconds: float) -> float:
+    """Return throughput in GB/s (decimal GB) for ``num_bytes`` over ``seconds``."""
+    return (num_bytes / 1e9) / seconds if seconds > 0 else float("inf")
+
+
+def _create_l1_manager(cfg: BenchmarkConfig, size_bytes: int) -> L1MemoryManager:
+    """Create an L1 memory manager sized to ``size_bytes`` for this benchmark."""
+    manager_config = L1MemoryManagerConfig(
+        size_in_bytes=size_bytes,
+        use_lazy=cfg.use_lazy,
+        init_size_in_bytes=min(_LARGE_LAZY_INIT, size_bytes),
+        align_bytes=cfg.page_size,
+    )
+    return L1MemoryManager(manager_config)
+
+
+def _object_layout(cfg: BenchmarkConfig) -> MemoryLayoutDesc:
+    """Return the layout for a single ``object_size``-byte uint8 object."""
+    return MemoryLayoutDesc(
+        shapes=[torch.Size([cfg.object_size])], dtypes=[torch.uint8]
+    )
+
+
+############################################################
+# Server
+############################################################
+def server_main(cfg: BenchmarkConfig) -> None:
+    """Run the benchmark server: register a buffer and serve its catalog.
+
+    Args:
+        cfg: The benchmark configuration (``role == "server"``).
+
+    Raises:
+        RuntimeError: If the source pool cannot be allocated in the buffer.
+    """
+    pool_bytes = cfg.num_source_objects * cfg.object_size
+    if pool_bytes > cfg.buffer_size:
+        raise RuntimeError(
+            f"source pool ({pool_bytes / 1e9:.2f} GB = {cfg.num_source_objects} "
+            f"x {cfg.object_size / 1024**2:.1f} MiB) does not fit in the "
+            f"{cfg.buffer_size / 1e9:.2f} GB buffer; increase --buffer-size or "
+            f"reduce --num-source-objects / --object-size."
+        )
+
+    logger.debug(
+        "Allocating L1 buffer (%.2f GB) and %d source objects",
+        cfg.buffer_size / 1e9,
+        cfg.num_source_objects,
+    )
+    manager = _create_l1_manager(cfg, cfg.buffer_size)
+    source_objs: list = []
+    try:
+        error, source_objs = manager.allocate(
+            _object_layout(cfg), cfg.num_source_objects
+        )
+        if error != L1Error.SUCCESS:
+            raise RuntimeError(
+                f"Failed to allocate {cfg.num_source_objects} source objects: "
+                f"{error}. Increase --buffer-size or reduce "
+                f"--num-source-objects / --object-size."
+            )
+
+        # Always write a deterministic per-object byte pattern (object index
+        # mod 256) so that a client run with --verify can validate the
+        # transferred bytes without any extra coordination. This is a one-time
+        # cost at startup and does not affect the measured read throughput.
+        for index, obj in enumerate(source_objs):
+            assert obj.tensor is not None, "Failed to allocate tensor!"
+            obj.tensor.fill_(index % 256)
+
+        catalog = [
+            (obj.shm_offset, obj.shm_byte_length, index)
+            for index, obj in enumerate(source_objs)
+        ]
+
+        initialize_transfer_channel_context(
+            cfg.transfer_channel_type,
+            l1_memory_desc=manager.get_l1_memory_desc(),
+            listen_url=cfg.url,
+            advertise_url=cfg.url,
+            backends=[cfg.nixl_backend],
+        )
+        try:
+            _serve_catalog(cfg, catalog)
+        finally:
+            delete_transfer_channel_context()
+    finally:
+        if source_objs:
+            manager.free(source_objs)
+        manager.close()
+
+
+def _serve_catalog(cfg: BenchmarkConfig, catalog: list[tuple[int, int, int]]) -> None:
+    """Serve the source object catalog over a ZMQ REP socket until timeout."""
+    payload = json.dumps(
+        {
+            "page_size": cfg.page_size,
+            "object_size": cfg.object_size,
+            "objects": catalog,
+        }
+    ).encode()
+
+    socket = zmq.Context.instance().socket(zmq.REP)
+    socket.setsockopt(zmq.LINGER, 0)
+    socket.bind(_zmq_endpoint(cfg.control_url))
+    print(
+        f"[server] ready: transfer channel on {cfg.url}, "
+        f"catalog on {cfg.control_url} ({len(catalog)} source objects)",
+        flush=True,
+    )
+
+    poller = zmq.Poller()
+    poller.register(socket, zmq.POLLIN)
+    deadline = time.monotonic() + cfg.server_timeout
+    try:
+        while time.monotonic() < deadline:
+            events = dict(poller.poll(timeout=1000))
+            if socket in events:
+                socket.recv()
+                socket.send(payload)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        socket.close(linger=0)
+        print("[server] shut down", flush=True)
+
+
+############################################################
+# Client
+############################################################
+def client_main(cfg: BenchmarkConfig) -> bool:
+    """Run the benchmark client: read a subset of source objects and report.
+
+    Args:
+        cfg: The benchmark configuration (``role == "client"``).
+
+    Returns:
+        ``True`` on success.
+
+    Raises:
+        ValueError: If the server's page/object size or pool size is
+            incompatible with this client's configuration.
+        RuntimeError: If allocation or a read transfer fails.
+    """
+    catalog = _fetch_catalog(cfg)
+    if catalog["page_size"] != cfg.page_size:
+        raise ValueError(
+            f"page_size mismatch: client {cfg.page_size} vs server "
+            f"{catalog['page_size']}; they must match."
+        )
+    if catalog["object_size"] != cfg.object_size:
+        raise ValueError(
+            f"object_size mismatch: client {cfg.object_size} vs server "
+            f"{catalog['object_size']}; they must match."
+        )
+    source_objs = catalog["objects"]
+    if len(source_objs) < cfg.num_objects:
+        raise ValueError(
+            f"server has only {len(source_objs)} source objects, fewer than "
+            f"--num-objects ({cfg.num_objects})."
+        )
+
+    client_buffer = cfg.num_objects * cfg.object_size + _CLIENT_BUFFER_SLACK
+    manager = _create_l1_manager(cfg, client_buffer)
+    dst_objs: list = []
+    try:
+        error, dst_objs = manager.allocate(_object_layout(cfg), cfg.num_objects)
+        if error != L1Error.SUCCESS:
+            raise RuntimeError(
+                f"Failed to allocate {cfg.num_objects} destination objects: {error}."
+            )
+
+        ctx = initialize_transfer_channel_context(
+            cfg.transfer_channel_type,
+            l1_memory_desc=manager.get_l1_memory_desc(),
+            listen_url=cfg.listen_url,
+            advertise_url=cfg.listen_url,
+            backends=[cfg.nixl_backend],
+        )
+        try:
+            local_addrs = ctx.get_transfer_channel_address(
+                [(obj.shm_offset, obj.shm_byte_length) for obj in dst_objs]
+            )
+            rng = random.Random(cfg.seed)
+            chosen = rng.sample(source_objs, cfg.num_objects)
+            remote_addrs = [
+                TransferChannelAddress(offset=offset, size=size)
+                for offset, size, _ in chosen
+            ]
+            chosen_indices = [index for _, _, index in chosen]
+
+            connect_start = time.perf_counter()
+            client = ctx.get_transfer_channel_client(cfg.url)
+            print(
+                f"[client] connected in {time.perf_counter() - connect_start:.1f}s; "
+                f"reading {cfg.num_objects} objects x "
+                f"{cfg.object_size / 1024**2:.1f} MiB",
+                flush=True,
+            )
+
+            def one_read() -> float:
+                start = time.perf_counter()
+                task_id = client.submit_read(local_addrs, remote_addrs)
+                result = client.query_read_status(task_id)
+                while not result.is_finished():
+                    result = client.query_read_status(task_id)
+                elapsed = time.perf_counter() - start
+                succeeded = sum(result.succeeded_mask)
+                if succeeded != cfg.num_objects:
+                    raise RuntimeError(
+                        f"read failed: {succeeded}/{cfg.num_objects} objects succeeded."
+                    )
+                return elapsed
+
+            for _ in range(cfg.warmup):
+                one_read()
+            times = [one_read() for _ in range(cfg.iters)]
+
+            if cfg.verify:
+                _verify(dst_objs, chosen_indices)
+
+            _report(cfg, times)
+            return True
+        finally:
+            delete_transfer_channel_context()
+            del ctx
+    finally:
+        if dst_objs:
+            manager.free(dst_objs)
+        manager.close()
+
+
+def _fetch_catalog(cfg: BenchmarkConfig) -> dict:
+    """Fetch the source object catalog from the server's control socket."""
+    socket = zmq.Context.instance().socket(zmq.REQ)
+    socket.setsockopt(zmq.LINGER, 0)
+    socket.setsockopt(zmq.RCVTIMEO, int(cfg.server_timeout * 1000))
+    socket.connect(_zmq_endpoint(cfg.control_url))
+    try:
+        socket.send(_CATALOG_REQUEST)
+        try:
+            reply = socket.recv()
+        except zmq.Again as exc:
+            raise RuntimeError(
+                f"timed out fetching catalog from {cfg.control_url}; is the "
+                f"server running?"
+            ) from exc
+    finally:
+        socket.close(linger=0)
+    return json.loads(reply)
+
+
+def _verify(dst_objs: list, chosen_indices: list[int]) -> None:
+    """Check each destination object holds the expected per-object byte pattern.
+
+    Raises:
+        RuntimeError: If any destination object does not match.
+    """
+    for obj, index in zip(dst_objs, chosen_indices, strict=False):
+        expected = index % 256
+        tensor = obj.tensor
+        if tensor is None or not bool((tensor == expected).all()):
+            raise RuntimeError(
+                f"verify FAILED for source object {index}: expected all bytes "
+                f"== {expected}."
+            )
+    print(
+        f"[client] verify OK: {len(dst_objs)} objects match expected pattern",
+        flush=True,
+    )
+
+
+def _report(cfg: BenchmarkConfig, times: list[float]) -> None:
+    """Print best/median/mean latency and throughput for the measured reads."""
+    total_bytes = cfg.num_objects * cfg.object_size
+    ordered = sorted(times)
+    best = ordered[0]
+    median = ordered[len(ordered) // 2]
+    mean = sum(ordered) / len(ordered)
+    print("\n==== Transfer channel read throughput ====", flush=True)
+    print(f"  channel type     : {cfg.transfer_channel_type}", flush=True)
+    print(
+        f"  payload per read : {total_bytes / 1e9:.3f} GB "
+        f"({cfg.num_objects} objs x {cfg.object_size / 1024**2:.1f} MiB)",
+        flush=True,
+    )
+    print(f"  iterations       : {cfg.iters} (warmup {cfg.warmup})", flush=True)
+    print(
+        f"  best   : {best * 1e3:8.2f} ms   {_gbps(total_bytes, best):7.2f} GB/s",
+        flush=True,
+    )
+    print(
+        f"  median : {median * 1e3:8.2f} ms   {_gbps(total_bytes, median):7.2f} GB/s",
+        flush=True,
+    )
+    print(
+        f"  mean   : {mean * 1e3:8.2f} ms   {_gbps(total_bytes, mean):7.2f} GB/s",
+        flush=True,
+    )
+
+
+############################################################
+# Entry
+############################################################
+def run_benchmark(args: argparse.Namespace) -> bool:
+    """Dispatch to the server or client role.
+
+    Args:
+        args: Parsed CLI arguments produced by ``add_benchmark_arguments``.
+
+    Returns:
+        ``True`` on success, ``False`` otherwise.
+    """
+    cfg = build_config(args)
+    if cfg.role == "server":
+        server_main(cfg)
+        return True
+    return client_main(cfg)