From 5be16e3539d768a316bb4f7050f4d56adac53312 Mon Sep 17 00:00:00 2001 From: neo-th Date: Mon, 2 Nov 2026 01:21:26 -0600 Subject: [PATCH 1/9] Add LMCache L2 adapter and correct KV and pipelined loader claims Adapter: - Add hypercache.integrations.lmcache_l2, a plugin L2 adapter for LMCache multiprocess mode, tested on LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0. - Any doubt about a block is a miss. A required namespace covers the model revision that LMCache's key lacks. Daemon, backward compatible on the wire: - Add a LOCAL_ONLY status: never flushed to a backend, stays evictable. - Add optional local_only and chunk_checksums to commit_write. - Report sync_status on locate HITs. Client: - HyperCacheKVStore commits local-only unless write_through is set, and treats staged blocks as misses. - DirectBlockWriter retries short writes and gains an opt-in O_DIRECT mode for raw block devices. Only the LMCache adapter turns it on. Docs: - Correct the pipelined loader claims using measured time to first token. - Remove the LMCache and Dynamo KVBM readiness claims. - Fix the pipelined loader README example. Results and scripts are in benchmarks/ and scripts/e2e/. Refs #2 --- AGENTS.md | 5 +- CHANGELOG.md | 27 + README.md | 40 +- benchmarks/pipelined_ttft.py | 299 +++++++++++ benchmarks/raw_write_probe.py | 165 ++++++ benchmarks/results/lmcache_and_ttft.md | 137 +++++ .../lmcache-0.5.5/fs_native_odirect-1.json | 73 +++ .../lmcache-0.5.5/fs_native_odirect-2.json | 73 +++ .../lmcache-0.5.5/fs_native_odirect-3.json | 73 +++ .../lmcache-0.5.5/fs_native_odirect_w8-1.json | 73 +++ .../lmcache-0.5.5/fs_native_odirect_w8-2.json | 73 +++ .../lmcache-0.5.5/fs_native_odirect_w8-3.json | 73 +++ .../lmcache-0.5.5/hypercache_arena_w8-1.json | 73 +++ .../lmcache-0.5.5/hypercache_arena_w8-2.json | 73 +++ .../lmcache-0.5.5/hypercache_arena_w8-3.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w4-1.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w4-2.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w4-3.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w8-1.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w8-2.json | 73 +++ .../lmcache-0.5.5/hypercache_raw_w8-3.json | 73 +++ .../hypercache_raw_w16-1.json | 73 +++ .../hypercache_raw_w16-2.json | 73 +++ .../hypercache_raw_w16-3.json | 73 +++ .../hypercache_raw_w2-1.json | 73 +++ .../hypercache_raw_w2-2.json | 73 +++ .../hypercache_raw_w2-3.json | 73 +++ .../hypercache_raw_w4-1.json | 73 +++ .../hypercache_raw_w4-2.json | 73 +++ .../hypercache_raw_w4-3.json | 73 +++ .../hypercache_raw_w4_l1unaligned-1.json | 73 +++ .../hypercache_raw_w4_l1unaligned-2.json | 73 +++ .../hypercache_raw_w4_l1unaligned-3.json | 73 +++ .../hypercache_raw_w8-1.json | 73 +++ .../hypercache_raw_w8-2.json | 73 +++ .../hypercache_raw_w8-3.json | 73 +++ .../lmcache-0.5.6-odirect/raw_block_w8-1.json | 73 +++ .../lmcache-0.5.6-odirect/raw_block_w8-2.json | 73 +++ .../lmcache-0.5.6-odirect/raw_block_w8-3.json | 73 +++ .../lmcache-0.5.6/fs_native_odirect-1.json | 73 +++ .../lmcache-0.5.6/fs_native_odirect-2.json | 73 +++ .../lmcache-0.5.6/fs_native_odirect-3.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w2-1.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w2-2.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w2-3.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w4-1.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w4-2.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w4-3.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w8-1.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w8-2.json | 73 +++ .../lmcache-0.5.6/hypercache_raw_w8-3.json | 73 +++ .../lmcache-0.5.6/raw_block_default-1.json | 73 +++ .../lmcache-0.5.6/raw_block_default-2.json | 73 +++ .../lmcache-0.5.6/raw_block_default-3.json | 73 +++ .../lmcache-0.5.6/raw_block_w8-1.json | 73 +++ .../lmcache-0.5.6/raw_block_w8-2.json | 73 +++ .../lmcache-0.5.6/raw_block_w8-3.json | 73 +++ benchmarks/results/pipelined_ttft.json | 190 +++++++ benchmarks/results/raw_write_probe.jsonl | 39 ++ benchmarks/write_concurrency_probe.py | 30 ++ client-py/hypercache/client.py | 14 + client-py/hypercache/datapath.py | 119 ++++- .../hypercache/integrations/lmcache_l2.py | 427 +++++++++++++++ client-py/hypercache/kv_store.py | 25 +- client-py/hypercache/pipeline.py | 17 +- client-py/pyproject.toml | 3 + client-py/tests/test_direct_writer.py | 229 +++++++++ client-py/tests/test_lmcache_adapter.py | 484 ++++++++++++++++++ control-plane/src/protocol.rs | 17 +- control-plane/src/server.rs | 147 +++++- scripts/e2e/lmcache_l2_e2e.py | 213 ++++++++ scripts/e2e/lmcache_vllm_e2e.py | 24 + 72 files changed, 6334 insertions(+), 40 deletions(-) create mode 100644 benchmarks/pipelined_ttft.py create mode 100644 benchmarks/raw_write_probe.py create mode 100644 benchmarks/results/lmcache_and_ttft.md create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-3.json create mode 100644 benchmarks/results/pipelined_ttft.json create mode 100644 benchmarks/results/raw_write_probe.jsonl create mode 100644 benchmarks/write_concurrency_probe.py create mode 100644 client-py/hypercache/integrations/lmcache_l2.py create mode 100644 client-py/tests/test_direct_writer.py create mode 100644 client-py/tests/test_lmcache_adapter.py create mode 100644 scripts/e2e/lmcache_l2_e2e.py create mode 100644 scripts/e2e/lmcache_vllm_e2e.py diff --git a/AGENTS.md b/AGENTS.md index 2b7c506..6fdc72c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -110,14 +110,17 @@ hypercache-poc/ │ ├── datapath.py # Direct Block DMA / GDS direct I/O reader │ ├── fsspec_fs.py # AbstractFileSystem implementation for torch.load/save │ ├── kv_store.py # Content-addressed KV-Cache Prefix Block Store - │ ├── pipeline.py # Double-buffered pipelined GPU tensor loader + │ ├── pipeline.py # In-order byte-range reader with background prefetch; returns bytes, runs no model │ └── integrations/ + │ ├── lmcache_l2.py # LMCache L2 plugin adapter; the only module importing lmcache, never imported by integrations/__init__.py │ ├── safetensors_loader.py # Zero-copy Safetensors & vLLM weight loader │ └── dcp.py # PyTorch Distributed Checkpoint (DCP) StorageReader/Writer └── tests/ ├── test_client.py # Unit tests for UDS protocol and client metadata parsing ├── test_fsspec.py # Unit tests for fsspec file operations and streaming writes ├── test_integrations_and_kv.py # Unit tests for Safetensors/vLLM, DCP, and KV-Cache store + ├── test_direct_writer.py # DirectBlockWriter O_DIRECT mode: alignment, partial blocks, fallbacks + ├── test_lmcache_adapter.py # LMCache L2 adapter against a fake daemon; stubs LMCache where absent ├── test_pipelined_and_numa.py # Unit tests for pipelined DMA and NUMA affinity └── test_robustness.py # Thread/fork safety, framing, O_DIRECT bounce buffers, CRC verification ``` diff --git a/CHANGELOG.md b/CHANGELOG.md index b0c966a..5afba96 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,32 @@ # Changelog +## Unreleased + +### Added +- `hypercache.integrations.lmcache_l2`: an L2 adapter for LMCache multiprocess mode, tested on + LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0. Optional extra: `hypercache[lmcache]`. +- `commit_write` accepts `local_only` and `chunk_checksums`. A `LOCAL_ONLY` object is never flushed + to a backend and stays evictable. Both fields are optional on the wire; older clients are unaffected. +- `locate` reports `sync_status` for HITs, so a reader can refuse an object that is still staged. +- `DirectBlockWriter(direct_on_block_devices=True)` writes to raw block devices with O_DIRECT, falling + back to the page cache for anything it can't take. Off by default; the LMCache adapter turns it on. +- `benchmarks/pipelined_ttft.py`, `benchmarks/write_concurrency_probe.py`, `benchmarks/raw_write_probe.py` and + `benchmarks/results/lmcache_and_ttft.md`. + +### Fixes +- `HyperCacheKVStore` commits are now `LOCAL_ONLY` unless `write_through` is set. Previously every + commit started a backend upload of prompt-derived data, ignoring `auto_flush_s3=False`, and a failed + upload left the block dirty and impossible to evict. Reads now treat staged blocks as misses. +- `DirectBlockWriter` retries short writes instead of ignoring them, no longer copies each chunk, and + no longer leaks a file descriptor when two threads open the same device. + +### Docs +- Corrected the pipelined loader claims. It does not shorten time to first token by itself: on a + 15 GB model the change was between -3.4% and +1.1%, and the first layer took 880 ms, not milliseconds. +- Fixed the pipelined loader README example, which did not match the API. +- Removed the claims of LMCache and Dynamo KVBM readiness. LMCache now has a real adapter; Dynamo + KVBM has no integration. + ## 0.9.3 Raw-block access for non-root clients and up-front arena sizing, tested on bare-metal Linux, diff --git a/README.md b/README.md index 5c65c9c..a0a5699 100644 --- a/README.md +++ b/README.md @@ -107,7 +107,7 @@ HyperCache is designed for both **AI Inference** and **Distributed AI Training** ### 1. Fast LLM Inference Cold Starts & Serverless GPU Scaling * **Pre-Warm Models Fleet-Wide**: Use `./hypercache-admin preload` to stage base models onto local NVMe or RAM across your cluster ahead of traffic spikes. -* **Layer-by-Layer Pipelined Loading (`HyperCachePipelinedLoader`)**: Instead of waiting for 100% of a model to load before starting inference, HyperCache loads Layer 0 in milliseconds so GPU forward-pass compute starts immediately while background DMA threads prefetch Layers $1, 2, \dots, N$ ahead of execution. +* **Layer-by-Layer Pipelined Loading (`HyperCachePipelinedLoader`)**: Reads a model's byte ranges in order and prefetches the next ones in the background, so an engine that can run layers as their weights arrive can overlap compute with I/O. It does not shorten time to first token by itself: the first token needs every layer, so the saving is at most `min(T_io, T_compute)`. In [our test](benchmarks/results/lmcache_and_ttft.md) on a 15 GB model, time to first token moved between -3.4% and +1.1%. * **Zero-Copy Multi-Tenant Model Sharing (`MAP_SHARED`)**: If you run multiple inference worker processes or containers on the same machine, they map the exact same physical RAM pages in Tier 1 shared memory with **0 bytes of memory duplication**. ### 2. Sub-Millisecond Multi-LoRA Adapter Hot-Swapping @@ -124,7 +124,7 @@ HyperCache is designed for both **AI Inference** and **Distributed AI Training** * Each node caches only its assigned $1/N$ slice of the dataset and streams batches into local PyTorch `DataLoader` workers at local NVMe line rate with zero network traffic. Because it uses consistent hashing, adding or removing a node only remaps $1/N$ of the shards instead of invalidating the entire cluster cache. ### 5. LLM KV-Cache Prefix Block Offloading (`HyperCacheKVStore`) -* Long-context LLM serving generates massive KV-cache tensors. Rather than recomputing shared prompt prefixes when GPU VRAM fills up, inference engines (and frameworks like LMCache or Dynamo KVBM) can use `HyperCacheKVStore` to offload content-addressed KV-cache blocks into Tier 1 Host RAM with automatic spillover to Tier 2 NVMe. +* Long-context LLM serving generates massive KV-cache tensors. Rather than recomputing shared prompt prefixes when GPU VRAM fills up, LMCache can keep them on HyperCache through `hypercache.integrations.lmcache_l2`, and other code can use `HyperCacheKVStore` directly. Blocks stay on the local host and remain evictable. There is no NVIDIA Dynamo KVBM integration. ### 6. Peer-to-Peer (P2P) Fleet Distribution * When preloading a large model across a multi-node cluster, you do not want every node pulling the full file from S3 simultaneously. @@ -679,21 +679,41 @@ state_dict = reader.load_rank_shard() ### 5. Layer-by-Layer Pipelined Model Loader (Compute / I/O Overlap) -Start forward-pass compute on Layer 0 immediately while subsequent layers prefetch in the background: +Read a model in order while the next byte ranges prefetch in the background: ```python from hypercache.pipeline import HyperCachePipelinedLoader -loader = HyperCachePipelinedLoader(prefetch_depth=2) +loader = HyperCachePipelinedLoader("hypercache://models/model.bin", num_layers=30, prefetch_ahead=2) -# Layer 0 arrives immediately; Layers 1..N prefetch in background threads during GPU compute -for layer_idx, layer_bytes in loader.stream_layers(layer_uris): - run_layer_forward_pass(layer_idx, layer_bytes) +for layer, layer_bytes in loader.stream_layers(): + run_layer_forward_pass(layer.layer_idx, layer_bytes) ``` -### 6. KV-Cache Prefix Block Store (LMCache / Dynamo KVBM Ready) +The loader splits the object by bytes and returns bytes. Your code has to supply true layer boundaries (`loader.layers`), turn bytes into tensors and run the model. The first token still needs every layer, so the saving is at most `min(T_io, T_compute)`. See the [measurements](benchmarks/results/lmcache_and_ttft.md). -Offload and retrieve prompt prefix KV-cache blocks on striped local NVMe (or optional Host RAM): +### 6. KV-Cache Storage for LMCache + +`hypercache.integrations.lmcache_l2` is an L2 adapter for LMCache's multiprocess mode, tested with LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0. It needs a daemon built from this version or later. Install `hypercache[lmcache]` where the LMCache server runs, and pass: + +```bash +lmcache server --l1-size-gb 60 --eviction-policy LRU --l2-adapter '{ + "type": "plugin", + "module_path": "hypercache.integrations.lmcache_l2", + "class_name": "HyperCacheL2Adapter", + "adapter_params": {"namespace": "my-model-rev-abc123", "tier": "nvme"} +}' +``` + +- **`namespace` is required.** LMCache's key has no model revision or dtype, so change this value whenever the weights or dtype change. Otherwise a new model could read the old model's KV data. +- **Blocks stay local.** They are never flushed to a backend, because they derive from user prompts and can be recomputed. They stay evictable, and the daemon manages capacity. +- **Doubt means a miss.** Every load verifies a CRC32 per chunk. A failed check reports a miss and removes the block. +- **Not supported:** `list_l2_keys` and LMCache's IsolatedLRU quotas. +- **Size L1 for loads.** Loads go through L1, and LMCache only evicts it down to 80%. If the load doesn't fit, vLLM recomputes. + +See the [results](benchmarks/results/lmcache_and_ttft.md). On our test drive in raw mode, the adapter's loads were within 0.4% of LMCache's `raw_block` adapter and its stores about 4% slower, while also verifying a CRC32 on every chunk. In filesystem arena mode, its loads were within 1% of `fs_native` with O_DIRECT and its stores about 20% slower. + +For code that manages its own KV blocks, use `HyperCacheKVStore`: ```python from hypercache import HyperCacheKVStore @@ -706,7 +726,7 @@ block_key = kv_store.compute_prefix_hash( ) # Store KV-cache block into local striped NVMe -kv_store.put_kv_block(block_key, kv_tensor, tier="nvme", pinned=True) +kv_store.put_kv_block(block_key, kv_tensor, tier="nvme") # Retrieve KV-cache block directly into pre-allocated GPU tensor kv_store.get_kv_block(block_key, out_tensor=gpu_kv_buffer) diff --git a/benchmarks/pipelined_ttft.py b/benchmarks/pipelined_ttft.py new file mode 100644 index 0000000..11b4252 --- /dev/null +++ b/benchmarks/pipelined_ttft.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python3 +""" +Measures what HyperCachePipelinedLoader does to time to first token (TTFT). + +A forward pass needs every layer, so overlapping compute with I/O can save at most +min(T_io, T_compute). This compares, on a real model and the same read path: + + eager: read and transfer every layer, then run the forward pass + pipelined: start the forward pass after the first layer; each layer waits for its own weights + +The weights are rewritten into a layer-ordered object first. HyperCache's own loader splits by +byte range only, so this script gives it true layer boundaries and does the model wiring. + +Timing starts just before the loader is created. CUDA start-up and building the empty model +happen earlier and are excluded for both modes. + + python3 benchmarks/pipelined_ttft.py --model-dir /path/to/snapshot --socket /run/hc/hc.sock \ + --output benchmarks/results/pipelined_ttft.json +""" + +import argparse +import ctypes +import gc +import glob +import json +import os +import platform +import statistics +import subprocess +import time +import warnings +import zlib + +import torch +from safetensors import safe_open +from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer + +from hypercache.client import HyperCacheClient +from hypercache.datapath import DirectBlockWriter +from hypercache.pipeline import HyperCachePipelinedLoader, LayerDescriptor + +warnings.filterwarnings("ignore", message=".*non-writable.*") + +URI = "hypercache://models/ttft/ordered-weights.bin" +PROMPT_SENTENCE = "The quick brown fox jumps over the lazy dog near the quiet river bank. " + + +def layer_group(name): + if name.startswith("model.embed_tokens"): + return 0 + if name.startswith("model.layers."): + return int(name.split(".")[2]) + 1 + return 10_000 # final norm and lm_head run last + + +def build_manifest(model_dir): + tensors = [] + for path in sorted(glob.glob(os.path.join(model_dir, "*.safetensors"))): + with safe_open(path, framework="pt") as f: + for name in f.keys(): + tensors.append((layer_group(name), name, path)) + tensors.sort(key=lambda t: (t[0], t[1])) + + entries, offset = [], 0 + for group, name, path in tensors: + with safe_open(path, framework="pt") as f: + piece = f.get_slice(name) + shape, dtype = piece.get_shape(), piece.get_dtype() + itemsize = {"F16": 2, "BF16": 2, "F32": 4}[dtype] + length = itemsize * max(1, int(torch.tensor(shape, dtype=torch.long).prod().item())) + entries.append( + {"group": group, "name": name, "path": path, "offset": offset, "length": length, "shape": shape, "dtype": dtype} + ) + offset += length + return entries, offset + + +def ingest(client, entries, total): + location = client.locate(URI, auto_ingest=False) + if location.is_hit and location.sync_status == "LOCAL_ONLY" and location.object_size == total: + print("Ordered weights already in HyperCache", flush=True) + return + print(f"Writing {total / 1e9:.1f} GB of layer-ordered weights to HyperCache", flush=True) + data = bytearray(total) + view = memoryview(data) + for entry in entries: + with safe_open(entry["path"], framework="pt") as f: + tensor = f.get_tensor(entry["name"]) + raw = ctypes.string_at(tensor.data_ptr(), entry["length"]) # numpy has no bfloat16 + view[entry["offset"] : entry["offset"] + entry["length"]] = raw + staged = client.stage_write(URI, total, tier="nvme", auto_flush_s3=False) + if not staged.is_staged: + raise RuntimeError(staged.error_message) + writer = DirectBlockWriter() + writer.write_chunks(staged.chunk_layout, view) + writer.close() + crcs, position = [], 0 + for chunk in staged.chunk_layout: + crcs.append(zlib.crc32(view[position : position + chunk.length]) & 0xFFFFFFFF) + position += chunk.length + if not client.commit_write(URI, local_only=True, chunk_checksums=crcs): + raise RuntimeError("commit failed") + + +def descriptors(entries): + groups = sorted({e["group"] for e in entries}) + result = [] + for index, group in enumerate(groups): + members = [e for e in entries if e["group"] == group] + start = members[0]["offset"] + length = members[-1]["offset"] + members[-1]["length"] - start + result.append(LayerDescriptor(layer_idx=index, name=str(group), start_offset=start, length=length)) + return groups, result + + +class Run: + """One empty model plus the wiring to give each layer its weights.""" + + def __init__(self, config, entries, args, dtype): + self.entries = entries + self.dtype = dtype + self.device = args.device + with torch.device("meta"): + self.model = AutoModelForCausalLM.from_config(config, dtype=dtype, attn_implementation="sdpa") + self.model.eval() + # Rotary embeddings are computed buffers, not weights, so meta construction leaves them empty + rotary = self.model.model.rotary_emb + self.model.model.rotary_emb = type(rotary)(config=config, device=args.device) + self.groups, layers = descriptors(entries) + self.t0 = time.perf_counter() + self.loader = HyperCachePipelinedLoader( + URI, socket_path=args.socket, prefer_gds=False, prefetch_ahead=args.prefetch_ahead + ) + self.loader.layers = layers + self.first_layer = None + self.wait = 0.0 + + def materialize(self, index, data): + group = self.groups[index] + base = self.loader.layers[index].start_offset + for entry in (e for e in self.entries if e["group"] == group): + source_dtype = {"F16": torch.float16, "BF16": torch.bfloat16, "F32": torch.float32}[entry["dtype"]] + count = entry["length"] // torch.empty(0, dtype=source_dtype).element_size() + tensor = torch.frombuffer(data, dtype=source_dtype, count=count, offset=entry["offset"] - base) + tensor = tensor.view(entry["shape"]).to(self.device, dtype=self.dtype) + owner, _, leaf = entry["name"].rpartition(".") + self.model.get_submodule(owner)._parameters[leaf] = torch.nn.Parameter(tensor, requires_grad=False) + + def install_hooks(self): + inner = self.model.model + modules = [inner.embed_tokens, *inner.layers, inner.norm] + for index, module in enumerate(modules): + module.register_forward_pre_hook(self._hook(index)) + + def _hook(self, index): + def hook(_module, _args): + start = time.perf_counter() + if index == 0 and self.first_layer is not None: + data, self.first_layer = self.first_layer, None + else: + _, data = self.loader.get_layer(index) + self.materialize(index, data) + self.wait += time.perf_counter() - start + + return hook + + def forward(self, ids): + with torch.inference_mode(): + logits = self.model(input_ids=ids, use_cache=False, logits_to_keep=1).logits + token = int(logits[0, -1].argmax()) + if self.device == "cuda": + torch.cuda.synchronize() + return token + + def close(self): + self.loader.close() + del self.model + gc.collect() + if self.device == "cuda": + torch.cuda.empty_cache() + + +def run_eager(config, entries, args, ids, dtype): + run = Run(config, entries, args, dtype) + first_bytes = None + for layer, data in run.loader.stream_layers(): + if first_bytes is None: + first_bytes = time.perf_counter() - run.t0 + run.materialize(layer.layer_idx, data) + loaded = time.perf_counter() - run.t0 + token = run.forward(ids) + ttft = time.perf_counter() - run.t0 + # T_compute alone: the same pass again, with everything already on the GPU + start = time.perf_counter() + run.forward(ids) + compute = time.perf_counter() - start + run.close() + return {"token": token, "first_layer_s": first_bytes, "t_io_s": loaded, "ttft_s": ttft, "t_compute_s": compute} + + +def run_pipelined(config, entries, args, ids, dtype): + run = Run(config, entries, args, dtype) + run.install_hooks() + _, run.first_layer = run.loader.load_initial_layer() + first_bytes = time.perf_counter() - run.t0 + token = run.forward(ids) + ttft = time.perf_counter() - run.t0 + wait = run.wait + run.close() + return {"token": token, "first_layer_s": first_bytes, "ttft_s": ttft, "weight_wait_s": wait} + + +def median(rows, key): + return statistics.median(row[key] for row in rows) + + +def machine_info(device): + gpu = "" + if device == "cuda": + gpu = subprocess.run( + ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"], capture_output=True, text=True + ).stdout.strip() + return {"device": device, "gpu": gpu, "cpu_count": os.cpu_count(), "torch": torch.__version__, "python": platform.python_version(), "kernel": platform.release()} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--model-dir", required=True) + parser.add_argument("--socket", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda", choices=["cuda", "cpu"]) + parser.add_argument("--repeats", type=int, default=3) + parser.add_argument("--prefetch-ahead", type=int, default=2) + parser.add_argument("--prompt-tokens", type=int, nargs="+", default=[6, 2048, 8192]) + args = parser.parse_args() + + torch.zeros(1).to(args.device) # CUDA start-up is not part of what's being measured + config = AutoConfig.from_pretrained(args.model_dir) + tokenizer = AutoTokenizer.from_pretrained(args.model_dir) + entries, total = build_manifest(args.model_dir) + client = HyperCacheClient(socket_path=args.socket, timeout=600) + ingest(client, entries, total) + location = client.locate(URI, auto_ingest=False) + print(f"Object: {location.object_size} bytes, {len(location.chunk_layout)} chunks on {location.chunk_layout[0].device}") + client.close() + + dtype = {"BF16": torch.bfloat16, "F16": torch.float16, "F32": torch.float32}[entries[0]["dtype"]] + long_ids = tokenizer(PROMPT_SENTENCE * 1500, return_tensors="pt").input_ids + results = [] + for tokens in args.prompt_tokens: + if tokens <= 6: + ids = tokenizer("The capital of France is", return_tensors="pt").input_ids + else: + ids = long_ids[:, :tokens] + ids = ids.to(args.device) + eager_rows, pipelined_rows = [], [] + for repeat in range(args.repeats): + eager_rows.append(run_eager(config, entries, args, ids, dtype)) + pipelined_rows.append(run_pipelined(config, entries, args, ids, dtype)) + print(f"tokens={ids.shape[1]} repeat={repeat} eager={eager_rows[-1]} pipelined={pipelined_rows[-1]}", flush=True) + tokens_match = all(e["token"] == p["token"] for e, p in zip(eager_rows, pipelined_rows)) + row = { + "prompt_tokens": int(ids.shape[1]), + "next_token": tokenizer.decode([eager_rows[0]["token"]]), + "tokens_match": tokens_match, + "first_layer_ms": 1000 * median(pipelined_rows, "first_layer_s"), + "t_io_s": median(eager_rows, "t_io_s"), + "t_compute_s": median(eager_rows, "t_compute_s"), + "eager_ttft_s": median(eager_rows, "ttft_s"), + "pipelined_ttft_s": median(pipelined_rows, "ttft_s"), + "raw": {"eager": eager_rows, "pipelined": pipelined_rows}, + } + row["saving_s"] = row["eager_ttft_s"] - row["pipelined_ttft_s"] + row["saving_pct"] = 100 * row["saving_s"] / row["eager_ttft_s"] + row["bound_s"] = min(row["t_io_s"], row["t_compute_s"]) + results.append(row) + + output = { + "machine": machine_info(args.device), + "model": os.path.basename(args.model_dir.rstrip("/")), + "object_bytes": total, + "repeats": args.repeats, + "prefetch_ahead": args.prefetch_ahead, + "results": results, + } + os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True) + with open(args.output, "w") as f: + json.dump(output, f, indent=2) + print("tokens first_layer T_io T_compute eager_TTFT pipelined_TTFT saving bound match") + for r in results: + print( + f"{r['prompt_tokens']:>6} {r['first_layer_ms']:>8.1f}ms {r['t_io_s']:>5.2f}s {r['t_compute_s']:>7.3f}s " + f"{r['eager_ttft_s']:>8.2f}s {r['pipelined_ttft_s']:>12.2f}s {r['saving_s']:>6.2f}s {r['saving_pct']:>5.1f}% " + f"{r['bound_s']:>5.2f}s {r['tokens_match']}" + ) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/raw_write_probe.py b/benchmarks/raw_write_probe.py new file mode 100644 index 0000000..2c6154a --- /dev/null +++ b/benchmarks/raw_write_probe.py @@ -0,0 +1,165 @@ +#!/usr/bin/env python3 +""" +Finds which part of the raw write path lowers later read speed. No LMCache involved. + +Writes objects through the real daemon protocol using one write strategy, then reads them all +back with the real DirectBlockReader, CRC checks on. A failed CRC stops the run, so a strategy +that writes wrong data can't report a good number. The strategies live here, not in the product. + + pool each chunk goes to a shared thread pool, so chunks can land out of order (today's path) + inorder each object writes its chunks one after another + merged each object issues one write across its adjacent chunks + +Each runs through the page cache (buffered) or with O_DIRECT. Needs a running daemon on a raw device. + + python3 benchmarks/raw_write_probe.py --socket /run/hc/hc.sock --mode inorder --direct --parallel 8 +""" + +import argparse +import json +import mmap +import os +import statistics +import threading +import time +import zlib +from concurrent.futures import ThreadPoolExecutor + +from hypercache.client import HyperCacheClient +from hypercache.datapath import DirectBlockReader, DirectBlockWriter + +OBJECT_SIZE = 14 * 1024 * 1024 +BLOCK = 4096 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--socket", required=True) + parser.add_argument("--mode", required=True, choices=["pool", "inorder", "merged"]) + parser.add_argument("--direct", action="store_true") + parser.add_argument("--parallel", type=int, default=8) + parser.add_argument("--objects", type=int, default=512) + args = parser.parse_args() + + source = mmap.mmap(-1, OBJECT_SIZE) # page-aligned, as O_DIRECT requires + source.write(os.urandom(OBJECT_SIZE)) + view = memoryview(source) + + clients = threading.local() + fds = {} + fd_lock = threading.Lock() + product_writer = DirectBlockWriter(max_workers=8) + chunk_pool = ThreadPoolExecutor(8) + flags = os.O_RDWR | (os.O_DIRECT if args.direct else 0) + + def client(): + if not hasattr(clients, "client"): + clients.client = HyperCacheClient(socket_path=args.socket, timeout=120) + return clients.client + + def device_fd(path): + with fd_lock: + if path not in fds: + fds[path] = os.open(path, flags) + return fds[path] + + def pwrite_all(fd, data, offset): + while len(data) > 0: + written = os.pwrite(fd, data, offset) + data = data[written:] + offset += written + + def write_object(layout): + if args.mode == "pool" and not args.direct: + product_writer.write_chunks(layout, view) # exactly today's path + return + spans, position = [], 0 + for chunk in layout: + spans.append((chunk.device, chunk.offset, position, chunk.length)) + position += chunk.length + if args.mode == "merged": + merged = [spans[0]] + for device, offset, start, length in spans[1:]: + d, o, s, n = merged[-1] + if d == device and o + n == offset: + merged[-1] = (d, o, s, n + length) + else: + merged.append((device, offset, start, length)) + spans = merged + work = [(device_fd(d), view[s : s + n], o) for d, o, s, n in spans] + if args.mode == "pool": + for future in [chunk_pool.submit(pwrite_all, *item) for item in work]: + future.result() + else: + for item in work: + pwrite_all(*item) + + layouts = [None] * args.objects + commit_seconds = [0.0] * args.objects + + def put(index): + c = client() + uri = f"hypercache://kv_cache/probe/{index}.kv" + staged = c.stage_write(uri, OBJECT_SIZE, tier="nvme", auto_flush_s3=False) + if not staged.is_staged: + raise IOError(staged.error_message) + write_object(staged.chunk_layout) + crcs, position = [], 0 + for chunk in staged.chunk_layout: + crcs.append(zlib.crc32(view[position : position + chunk.length]) & 0xFFFFFFFF) + position += chunk.length + start = time.perf_counter() + if not c.commit_write(uri, local_only=True, chunk_checksums=crcs): + raise IOError("commit failed") + commit_seconds[index] = time.perf_counter() - start + layouts[index] = c.locate(uri, auto_ingest=False).chunk_layout + + total_mb = args.objects * OBJECT_SIZE / 1e6 + start = time.perf_counter() + with ThreadPoolExecutor(args.parallel) as pool: + list(pool.map(put, range(args.objects))) + write_mbps = total_mb / (time.perf_counter() - start) + + reader = DirectBlockReader(max_workers=8, verify_checksums=True) + buffers = [memoryview(mmap.mmap(-1, OBJECT_SIZE)) for _ in range(8)] + slots = iter(buffers) + slot_lock = threading.Lock() + local = threading.local() + + def get(layout): + if not hasattr(local, "buffer"): + with slot_lock: + local.buffer = next(slots) + if reader.read_range_into(layout, 0, OBJECT_SIZE, local.buffer) != OBJECT_SIZE: + raise IOError("short read") + + read_runs = [] + for _ in range(3): + start = time.perf_counter() + with ThreadPoolExecutor(8) as pool: + list(pool.map(get, layouts)) + read_runs.append(total_mb / (time.perf_counter() - start)) + local = threading.local() + slots = iter(buffers) + stats = reader.get_stats() + reader.close() + + print( + json.dumps( + { + "mode": args.mode, + "direct": args.direct, + "parallel": args.parallel, + "write_mbps": round(write_mbps), + "read_mbps": round(statistics.median(read_runs)), + "commit_ms_median": round(1000 * statistics.median(commit_seconds), 1), + "commit_ms_p99": round(1000 * sorted(commit_seconds)[int(0.99 * args.objects)], 1), + "reader_fallbacks": stats["direct_fallbacks"] + stats["buffered_reads"], + } + ), + flush=True, + ) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/results/lmcache_and_ttft.md b/benchmarks/results/lmcache_and_ttft.md new file mode 100644 index 0000000..47a3568 --- /dev/null +++ b/benchmarks/results/lmcache_and_ttft.md @@ -0,0 +1,137 @@ +# LMCache adapter and pipelined loader results + +Measured 2026-11-02 on one small server. These results show behaviour and relative cost on this machine. They are not throughput claims for production hardware. + +**Hardware:** Ryzen 5 5600GT, 31 GB RAM, RTX 4060 Ti 16 GB (PCIe Gen3 x8), Crucial P3 Gen3 x4 (ext4 on LVM), Intel SSDPEKNU512GZ Gen3 x2 (raw, about 1.4 GB/s direct read measured with dd). + +**Software:** Linux 6.8.0, vLLM 0.31.0, LMCache 0.5.5, torch 2.13.0+cu130, transformers 5.17.0, HyperCache 0.9.3 plus this change. The contract checks also passed on LMCache 0.5.6. + +## Pipelined loader: time to first token + +`benchmarks/pipelined_ttft.py` with Qwen2.5-7B-Instruct (bfloat16, 15.2 GB, 30 layer groups), on the raw Intel disk, `prefetch_ahead=2`. Medians of 3 runs, with raw data in `pipelined_ttft.json`. + +| Prompt tokens | First layer | T_io | T_compute | Eager TTFT | Pipelined TTFT | Saving | Limit | +|---:|---:|---:|---:|---:|---:|---:|---:| +| 5 | 880 ms | 15.06 s | 0.06 s | 15.14 s | 15.66 s | -0.52 s (-3.4%) | 0.06 s | +| 2048 | 878 ms | 15.16 s | 0.70 s | 15.88 s | 16.07 s | -0.20 s (-1.2%) | 0.70 s | +| 4096 | 881 ms | 15.21 s | 1.46 s | 16.67 s | 16.49 s | +0.18 s (+1.1%) | 1.46 s | + +- Both modes produced the same next token in every run. +- An 8192-token prompt ran out of VRAM with 15 GB of weights loaded. +- The first layer took 880 ms because it is the 1 GB embedding table. The cause of pipelined being slower on short prompts was not profiled. +- The limit is `min(T_io, T_compute)`. Faster storage shrinks T_io, so a long prompt on much faster storage could save a larger share. That case was not measured. + +## LMCache L2 adapter on the root disk: `lmcache bench l2` + +Same Crucial disk for all three, HyperCache in filesystem arena mode with 8 workers. 14 MiB objects, 8 keys per submit, 4 in flight, 5 rounds plus 1 warm-up. Median of 3 runs, range in brackets. Page cache dropped before each run. + +| Adapter | Store MB/s | Load MB/s | +|---|---:|---:| +| HyperCache | 1464 (1214-1465) | 3302 (3141-3355) | +| `fs_native`, O_DIRECT | 3003 (3003-3005) | 3405 (3395-3433) | +| `fs_native`, default | 5025 (5004-5063) | 7580 (7548-7758) | + +- HyperCache verifies a CRC32 on every load chunk, and syncs and computes CRCs before reporting a store. The store gap was not profiled. +- The default `fs_native` row includes the page cache, so it does not measure the disk. +- Lookup of 32 keys: 1.3 ms for HyperCache, 0.1 ms for `fs_native`. + +## LMCache L2 adapter on the raw drive + +The adapter now writes to raw devices with O_DIRECT. Medians of 3 runs in shuffled order, on the same Intel drive, wiped before each run, on LMCache 0.5.6. Same settings as the tables below. Raw JSON is in `lmcache_l2_raw/lmcache-0.5.6-odirect/`. + +| Adapter | Workers | L1 alignment | Store MB/s | Load MB/s | +|---|---:|---:|---:|---:| +| LMCache `raw_block` | 8 store, 8 load | 4096 | 1367 (1362-1368) | 1538 (1533-1538) | +| HyperCache | 2 | 4096 | 1310 (1309-1312) | 1452 (1451-1452) | +| HyperCache | 4 (default) | 4096 | 1313 (1313-1314) | 1532 (1531-1532) | +| HyperCache | 8 | 4096 | 1314 (1311-1315) | 1532 (1531-1537) | +| HyperCache | 16 | 4096 | 1310 (1309-1311) | 1533 (1528-1541) | +| HyperCache | 4 | 1 (unaligned buffers) | 1071 (1066-1072) | 1527 (1525-1533) | + +- **Against `raw_block`:** at the default 4 workers, loads are within 0.4% and stores about 4% slower. HyperCache also verifies a CRC32 per chunk on every load. +- **Against the page-cache path:** at 4 workers, store rose from 1098 to 1313 MB/s and load from 1390 to 1532 MB/s. At 8 workers, load rose from 1144 to 1532 MB/s. +- **Worker count no longer lowers load speed.** +- **Unaligned L1 buffers** cost about 18% on stores because of the extra copy. LMCache's default L1 alignment is 4096, so the aligned rows are the expected case. +- These loads are near this drive's limit of about 1.6 GB/s, so a faster drive could show differences this one hides. +- `raw_block` with io_uring was not measured, because it could not start in this container. + +### Before O_DIRECT + +These runs used the page-cache write path. They are kept because they show the problem that led to the change. + +All rows use the same Intel drive, which was discarded with `blkdiscard` and had caches dropped before every run. 14 MiB objects, 8 keys per submit, 4 in flight, 20 rounds plus 2 warm-up. Median of 3 runs, range in brackets. Every store and load succeeded. Raw JSON is in `lmcache_l2_raw/`. + +**LMCache 0.5.6:** + +| Adapter | Mode | Workers | Store MB/s | Load MB/s | +|---|---|---:|---:|---:| +| LMCache `raw_block` | Raw | 2 store, 4 load (default) | 1327 (1324-1363) | 1534 (1531-1537) | +| LMCache `raw_block` | Raw | 8 store, 8 load | 1366 (1361-1369) | 1534 (1532-1535) | +| HyperCache | Raw | 2 | 906 (905-907) | 1423 (1408-1426) | +| HyperCache | Raw | 4 | 1098 (1095-1098) | 1390 (1375-1394) | +| HyperCache | Raw | 8 | 1127 (1125-1131) | 1144 (1143-1144) | +| LMCache `fs_native`, O_DIRECT | ext4 | 4 (default) | 1327 (1325-1332) | 1513 (1508-1513) | + +**LMCache 0.5.5:** + +| Adapter | Mode | Workers | Store MB/s | Load MB/s | +|---|---|---:|---:|---:| +| HyperCache | Filesystem arena on ext4 | 8 | 1064 (1061-1082) | 1500 (1496-1501) | +| LMCache `fs_native`, O_DIRECT | ext4 | 8 | 1343 (1340-1345) | 1514 (1511-1515) | + +- **HyperCache raw with 4 workers against `raw_block`:** loads are about 9% slower and stores about 20% slower. With 8 workers, loads are about 25% slower. +- **HyperCache's raw mode is not faster than its arena mode here.** At 8 workers the arena loaded at 1500 MB/s against 1144 for raw. Single runs at 4 workers gave 1445 against about 1390. The arena stored more slowly in both. +- **Not measured:** `raw_block` with io_uring failed to start in this container ("Operation not permitted"). +- **Setup differences:** `raw_block` ran with a fixed 14 MiB slot and periodic metadata checkpoints turned off, which may favour it. HyperCache computes and verifies a CRC32 per chunk; a direct probe put verification at about 3% of read throughput. A search of `raw_block`'s source found CRC checks only on its metadata checkpoints, not on KV data. Durability was not tested for either adapter. + +### Why more workers lowered raw load speed + +`benchmarks/write_concurrency_probe.py` writes through HyperCache's client at a chosen parallelism, then reads everything back, with no LMCache involved: + +| Objects written in parallel | Write MB/s | Read MB/s (4, 8 or 16 parallel readers) | +|---:|---:|---:| +| 1 | 812-815 | 1574-1617 | +| 8 | 1179 | 1225-1251 | +| 16 | 1194 | 1133-1153 | + +Read parallelism made almost no difference. Write parallelism did. + +`benchmarks/raw_write_probe.py` then tested the write method directly, on a freshly wiped drive for each of 3 runs, in shuffled order, with CRC checks on during reads. Medians, 512 objects of 14 MiB. Raw data is in `raw_write_probe.jsonl`. + +| Write method | Objects in parallel | Write MB/s | Read MB/s | Commit median | +|---|---:|---:|---:|---:| +| Page cache, shared chunk pool (today's path) | 1 | 817 | 1616 | 10 ms | +| Page cache, shared chunk pool (today's path) | 4 | 1114 | 1420 | 39 ms | +| Page cache, shared chunk pool (today's path) | 8 | 1189 | 1214 | 77 ms | +| Page cache, shared chunk pool (today's path) | 16 | 1215 | 1134 | 158 ms | +| Page cache, chunks in order | 8 | 1089 | 1175 | 81 ms | +| Page cache, one write per object | 8 | 1090 | 1183 | 80 ms | +| O_DIRECT, shared chunk pool | 8 | 1363 | 1604 | 20 ms | +| O_DIRECT, chunks in order | 8 | 1394 | 1611 | 13 ms | +| O_DIRECT, one write per object | 4 | 1387 | 1605 | 16 ms | +| O_DIRECT, one write per object | 8 | 1392 | 1610 | 31 ms | +| O_DIRECT, one write per object | 16 | 1394 | 1616 | 58 ms | + +- **Writing through the page cache is what lowers later read speed.** With O_DIRECT, reads hold at about 1610 MB/s at every parallelism tested. +- **Chunk order is not the cause.** Writing chunks in order did not help through the page cache, and O_DIRECT did not need it. +- **O_DIRECT also improves writes,** from 1189 to about 1390 MB/s at 8 parallel objects. +- Why page-cache writeback has this effect on this drive was not investigated, so it may differ on other drives. These are probe numbers without LMCache. + +## Real serving path: vLLM, LMCache, adapter + +`scripts/e2e/lmcache_vllm_e2e.py` with Qwen2.5-7B-Instruct-AWQ, a prompt of about 9,500 tokens, 3 GB L1, HyperCache on the raw Intel disk. + +| Request | TTFT | Served from | +|---|---:|---| +| Cold | 3.55 s | Computed | +| Repeat | 0.20 s | L1 | +| After filling L1 with other prompts | 0.62 s | NVMe: 37 of 37 chunks in 402 ms | + +- These figures are with O_DIRECT writes. The NVMe case is from one run; before O_DIRECT, one run gave 0.68 s and 459 ms. +- The cold and repeat figures matched across every run. +- Generated text was identical across all three requests. +- With a 1 GB L1, the NVMe load could not get L1 buffers (LMCache only evicts down to 80%), so vLLM recomputed. The result was correct but slow, so size L1 above about 5x the largest expected load. + +## Safety checks + +`scripts/e2e/lmcache_l2_e2e.py` passed 18 of 18 on LMCache 0.5.5 and 0.5.6, with the real daemon on the raw disk. This includes a flipped byte on disk, which became a miss and was removed, and the same extents rewritten alternately through the page cache and O_DIRECT, with both read paths seeing the latest data each time. The daemon was pointed at an S3 endpoint with nothing listening, and logged no flush attempts across these runs. diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-1.json new file mode 100644 index 0000000..9a0cae6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 337.06, + "duration_min_ms": 322.17, + "duration_max_ms": 344.26, + "duration_p50_ms": 339.59, + "duration_p99_ms": 344.26, + "duration_std_ms": 7.3, + "throughput_avg_mbps": 1329.77, + "throughput_min_mbps": 1301.35, + "throughput_max_mbps": 1390.56, + "ops_per_sec_avg": 94.98, + "latency_per_key_ms": 10.533 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.15, + "duration_min_ms": 0.09, + "duration_max_ms": 0.26, + "duration_p50_ms": 0.12, + "duration_p99_ms": 0.26, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 239553.56, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 297.3, + "duration_min_ms": 294.31, + "duration_max_ms": 302.31, + "duration_p50_ms": 296.98, + "duration_p99_ms": 302.31, + "duration_std_ms": 2.35, + "throughput_avg_mbps": 1506.98, + "throughput_min_mbps": 1481.92, + "throughput_max_mbps": 1522.22, + "ops_per_sec_avg": 107.64, + "latency_per_key_ms": 9.291 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-2.json new file mode 100644 index 0000000..c8366b3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 337.5, + "duration_min_ms": 322.69, + "duration_max_ms": 345.18, + "duration_p50_ms": 339.92, + "duration_p99_ms": 345.18, + "duration_std_ms": 7.22, + "throughput_avg_mbps": 1328.0, + "throughput_min_mbps": 1297.86, + "throughput_max_mbps": 1388.32, + "ops_per_sec_avg": 94.86, + "latency_per_key_ms": 10.547 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.18, + "duration_min_ms": 0.1, + "duration_max_ms": 0.33, + "duration_p50_ms": 0.16, + "duration_p99_ms": 0.33, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 206793.58, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 296.14, + "duration_min_ms": 294.05, + "duration_max_ms": 300.97, + "duration_p50_ms": 296.05, + "duration_p99_ms": 300.97, + "duration_std_ms": 1.66, + "throughput_avg_mbps": 1512.82, + "throughput_min_mbps": 1488.53, + "throughput_max_mbps": 1523.54, + "ops_per_sec_avg": 108.06, + "latency_per_key_ms": 9.254 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-3.json new file mode 100644 index 0000000..ebe59f6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 333.44, + "duration_min_ms": 306.55, + "duration_max_ms": 344.39, + "duration_p50_ms": 337.21, + "duration_p99_ms": 344.39, + "duration_std_ms": 10.22, + "throughput_avg_mbps": 1344.82, + "throughput_min_mbps": 1300.85, + "throughput_max_mbps": 1461.43, + "ops_per_sec_avg": 96.06, + "latency_per_key_ms": 10.42 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.14, + "duration_min_ms": 0.09, + "duration_max_ms": 0.26, + "duration_p50_ms": 0.12, + "duration_p99_ms": 0.26, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 242211.78, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 296.02, + "duration_min_ms": 293.54, + "duration_max_ms": 299.65, + "duration_p50_ms": 296.16, + "duration_p99_ms": 299.65, + "duration_std_ms": 1.85, + "throughput_avg_mbps": 1513.46, + "throughput_min_mbps": 1495.07, + "throughput_max_mbps": 1526.21, + "ops_per_sec_avg": 108.1, + "latency_per_key_ms": 9.251 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-1.json new file mode 100644 index 0000000..6423ccf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true,\"num_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 333.86, + "duration_min_ms": 310.97, + "duration_max_ms": 343.2, + "duration_p50_ms": 337.2, + "duration_p99_ms": 343.2, + "duration_std_ms": 8.92, + "throughput_avg_mbps": 1342.83, + "throughput_min_mbps": 1305.34, + "throughput_max_mbps": 1440.65, + "ops_per_sec_avg": 95.92, + "latency_per_key_ms": 10.433 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.21, + "duration_min_ms": 0.1, + "duration_max_ms": 0.27, + "duration_p50_ms": 0.21, + "duration_p99_ms": 0.27, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 162499.85, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 296.44, + "duration_min_ms": 293.69, + "duration_max_ms": 302.11, + "duration_p50_ms": 295.93, + "duration_p99_ms": 302.11, + "duration_std_ms": 2.29, + "throughput_avg_mbps": 1511.38, + "throughput_min_mbps": 1482.89, + "throughput_max_mbps": 1525.44, + "ops_per_sec_avg": 107.96, + "latency_per_key_ms": 9.264 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-2.json new file mode 100644 index 0000000..92366f3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true,\"num_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 334.58, + "duration_min_ms": 317.65, + "duration_max_ms": 343.2, + "duration_p50_ms": 337.76, + "duration_p99_ms": 343.2, + "duration_std_ms": 7.85, + "throughput_avg_mbps": 1339.7, + "throughput_min_mbps": 1305.38, + "throughput_max_mbps": 1410.36, + "ops_per_sec_avg": 95.69, + "latency_per_key_ms": 10.456 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.21, + "duration_min_ms": 0.11, + "duration_max_ms": 0.35, + "duration_p50_ms": 0.21, + "duration_p99_ms": 0.35, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 162628.47, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 295.93, + "duration_min_ms": 293.47, + "duration_max_ms": 300.26, + "duration_p50_ms": 295.69, + "duration_p99_ms": 300.26, + "duration_std_ms": 1.93, + "throughput_avg_mbps": 1513.92, + "throughput_min_mbps": 1492.06, + "throughput_max_mbps": 1526.55, + "ops_per_sec_avg": 108.14, + "latency_per_key_ms": 9.248 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-3.json new file mode 100644 index 0000000..49674f4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/fs_native_odirect_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true,\"num_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 333.33, + "duration_min_ms": 308.0, + "duration_max_ms": 342.22, + "duration_p50_ms": 337.42, + "duration_p99_ms": 342.22, + "duration_std_ms": 9.05, + "throughput_avg_mbps": 1344.99, + "throughput_min_mbps": 1309.1, + "throughput_max_mbps": 1454.54, + "ops_per_sec_avg": 96.07, + "latency_per_key_ms": 10.417 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.21, + "duration_min_ms": 0.09, + "duration_max_ms": 0.36, + "duration_p50_ms": 0.18, + "duration_p99_ms": 0.36, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 166545.87, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 295.81, + "duration_min_ms": 292.39, + "duration_max_ms": 300.84, + "duration_p50_ms": 295.32, + "duration_p99_ms": 300.84, + "duration_std_ms": 2.28, + "throughput_avg_mbps": 1514.59, + "throughput_min_mbps": 1489.18, + "throughput_max_mbps": 1532.21, + "ops_per_sec_avg": 108.18, + "latency_per_key_ms": 9.244 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-1.json new file mode 100644 index 0000000..7fc69a3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 422.7, + "duration_min_ms": 388.72, + "duration_max_ms": 453.05, + "duration_p50_ms": 422.46, + "duration_p99_ms": 453.05, + "duration_std_ms": 15.23, + "throughput_avg_mbps": 1061.19, + "throughput_min_mbps": 988.86, + "throughput_max_mbps": 1152.49, + "ops_per_sec_avg": 75.8, + "latency_per_key_ms": 13.209 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.07, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24626.09, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 298.46, + "duration_min_ms": 295.24, + "duration_max_ms": 308.14, + "duration_p50_ms": 297.78, + "duration_p99_ms": 308.14, + "duration_std_ms": 3.09, + "throughput_avg_mbps": 1501.21, + "throughput_min_mbps": 1453.89, + "throughput_max_mbps": 1517.42, + "ops_per_sec_avg": 107.23, + "latency_per_key_ms": 9.327 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-2.json new file mode 100644 index 0000000..879b1cb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 414.76, + "duration_min_ms": 372.95, + "duration_max_ms": 446.08, + "duration_p50_ms": 416.41, + "duration_p99_ms": 446.08, + "duration_std_ms": 16.0, + "throughput_avg_mbps": 1081.72, + "throughput_min_mbps": 1004.3, + "throughput_max_mbps": 1201.23, + "ops_per_sec_avg": 77.27, + "latency_per_key_ms": 12.961 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.07, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24939.38, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 299.49, + "duration_min_ms": 297.68, + "duration_max_ms": 303.29, + "duration_p50_ms": 299.4, + "duration_p99_ms": 303.29, + "duration_std_ms": 1.48, + "throughput_avg_mbps": 1495.91, + "throughput_min_mbps": 1477.14, + "throughput_max_mbps": 1504.96, + "ops_per_sec_avg": 106.85, + "latency_per_key_ms": 9.359 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-3.json new file mode 100644 index 0000000..89a306a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_arena_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 421.49, + "duration_min_ms": 400.07, + "duration_max_ms": 462.06, + "duration_p50_ms": 420.24, + "duration_p99_ms": 462.06, + "duration_std_ms": 12.92, + "throughput_avg_mbps": 1063.8, + "throughput_min_mbps": 969.57, + "throughput_max_mbps": 1119.81, + "ops_per_sec_avg": 75.99, + "latency_per_key_ms": 13.172 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.21, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24382.04, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 298.75, + "duration_min_ms": 295.09, + "duration_max_ms": 301.82, + "duration_p50_ms": 298.77, + "duration_p99_ms": 301.82, + "duration_std_ms": 1.75, + "throughput_avg_mbps": 1499.61, + "throughput_min_mbps": 1484.33, + "throughput_max_mbps": 1518.17, + "ops_per_sec_avg": 107.11, + "latency_per_key_ms": 9.336 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-1.json new file mode 100644 index 0000000..2ccbd05 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 408.67, + "duration_min_ms": 390.17, + "duration_max_ms": 417.98, + "duration_p50_ms": 411.3, + "duration_p99_ms": 417.98, + "duration_std_ms": 7.92, + "throughput_avg_mbps": 1096.65, + "throughput_min_mbps": 1071.81, + "throughput_max_mbps": 1148.23, + "ops_per_sec_avg": 78.33, + "latency_per_key_ms": 12.771 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.28, + "duration_min_ms": 1.09, + "duration_max_ms": 1.49, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.49, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25253.13, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 325.33, + "duration_min_ms": 317.58, + "duration_max_ms": 334.16, + "duration_p50_ms": 324.18, + "duration_p99_ms": 334.16, + "duration_std_ms": 4.27, + "throughput_avg_mbps": 1377.29, + "throughput_min_mbps": 1340.69, + "throughput_max_mbps": 1410.67, + "ops_per_sec_avg": 98.38, + "latency_per_key_ms": 10.167 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-2.json new file mode 100644 index 0000000..7716652 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 408.39, + "duration_min_ms": 394.35, + "duration_max_ms": 415.66, + "duration_p50_ms": 410.18, + "duration_p99_ms": 415.66, + "duration_std_ms": 7.17, + "throughput_avg_mbps": 1097.33, + "throughput_min_mbps": 1077.82, + "throughput_max_mbps": 1136.05, + "ops_per_sec_avg": 78.38, + "latency_per_key_ms": 12.762 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.16, + "duration_max_ms": 1.42, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.42, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24881.58, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 325.39, + "duration_min_ms": 318.87, + "duration_max_ms": 331.3, + "duration_p50_ms": 324.46, + "duration_p99_ms": 331.3, + "duration_std_ms": 3.31, + "throughput_avg_mbps": 1376.93, + "throughput_min_mbps": 1352.23, + "throughput_max_mbps": 1404.95, + "ops_per_sec_avg": 98.35, + "latency_per_key_ms": 10.169 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-3.json new file mode 100644 index 0000000..78853a2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 408.76, + "duration_min_ms": 390.72, + "duration_max_ms": 418.04, + "duration_p50_ms": 411.81, + "duration_p99_ms": 418.04, + "duration_std_ms": 8.81, + "throughput_avg_mbps": 1096.48, + "throughput_min_mbps": 1071.66, + "throughput_max_mbps": 1146.62, + "ops_per_sec_avg": 78.32, + "latency_per_key_ms": 12.774 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.43, + "duration_min_ms": 1.16, + "duration_max_ms": 2.03, + "duration_p50_ms": 1.44, + "duration_p99_ms": 2.03, + "duration_std_ms": 0.2, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 22802.15, + "latency_per_key_ms": 0.045 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 322.09, + "duration_min_ms": 312.53, + "duration_max_ms": 337.68, + "duration_p50_ms": 322.5, + "duration_p99_ms": 337.68, + "duration_std_ms": 7.18, + "throughput_avg_mbps": 1391.57, + "throughput_min_mbps": 1326.69, + "throughput_max_mbps": 1433.45, + "ops_per_sec_avg": 99.4, + "latency_per_key_ms": 10.065 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-1.json new file mode 100644 index 0000000..da8df22 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 398.11, + "duration_min_ms": 378.73, + "duration_max_ms": 407.18, + "duration_p50_ms": 399.79, + "duration_p99_ms": 407.18, + "duration_std_ms": 7.6, + "throughput_avg_mbps": 1125.73, + "throughput_min_mbps": 1100.26, + "throughput_max_mbps": 1182.9, + "ops_per_sec_avg": 80.41, + "latency_per_key_ms": 12.441 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.3, + "duration_min_ms": 1.18, + "duration_max_ms": 1.38, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.38, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24688.46, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 393.25, + "duration_min_ms": 384.08, + "duration_max_ms": 402.58, + "duration_p50_ms": 393.17, + "duration_p99_ms": 402.58, + "duration_std_ms": 4.43, + "throughput_avg_mbps": 1139.36, + "throughput_min_mbps": 1112.83, + "throughput_max_mbps": 1166.42, + "ops_per_sec_avg": 81.38, + "latency_per_key_ms": 12.289 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-2.json new file mode 100644 index 0000000..1a9a51e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 397.02, + "duration_min_ms": 375.79, + "duration_max_ms": 439.94, + "duration_p50_ms": 398.17, + "duration_p99_ms": 439.94, + "duration_std_ms": 12.98, + "throughput_avg_mbps": 1129.52, + "throughput_min_mbps": 1018.33, + "throughput_max_mbps": 1192.17, + "ops_per_sec_avg": 80.68, + "latency_per_key_ms": 12.407 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.03, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24443.44, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 390.42, + "duration_min_ms": 383.75, + "duration_max_ms": 405.25, + "duration_p50_ms": 387.99, + "duration_p99_ms": 405.25, + "duration_std_ms": 5.43, + "throughput_avg_mbps": 1147.69, + "throughput_min_mbps": 1105.49, + "throughput_max_mbps": 1167.43, + "ops_per_sec_avg": 81.98, + "latency_per_key_ms": 12.201 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-3.json new file mode 100644 index 0000000..8a5e2e1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.5/hypercache_raw_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 398.76, + "duration_min_ms": 384.03, + "duration_max_ms": 417.22, + "duration_p50_ms": 399.62, + "duration_p99_ms": 417.22, + "duration_std_ms": 8.66, + "throughput_avg_mbps": 1123.99, + "throughput_min_mbps": 1073.77, + "throughput_max_mbps": 1166.59, + "ops_per_sec_avg": 80.29, + "latency_per_key_ms": 12.461 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.28, + "duration_min_ms": 1.01, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25129.92, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 395.43, + "duration_min_ms": 374.77, + "duration_max_ms": 404.62, + "duration_p50_ms": 395.03, + "duration_p99_ms": 404.62, + "duration_std_ms": 8.92, + "throughput_avg_mbps": 1133.52, + "throughput_min_mbps": 1107.2, + "throughput_max_mbps": 1195.39, + "ops_per_sec_avg": 80.97, + "latency_per_key_ms": 12.357 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-1.json new file mode 100644 index 0000000..a6e599d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 342.06, + "duration_min_ms": 324.42, + "duration_max_ms": 350.67, + "duration_p50_ms": 344.99, + "duration_p99_ms": 350.67, + "duration_std_ms": 7.7, + "throughput_avg_mbps": 1310.37, + "throughput_min_mbps": 1277.54, + "throughput_max_mbps": 1380.91, + "ops_per_sec_avg": 93.6, + "latency_per_key_ms": 10.689 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.08, + "duration_max_ms": 1.41, + "duration_p50_ms": 1.3, + "duration_p99_ms": 1.41, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24983.69, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 290.73, + "duration_min_ms": 289.09, + "duration_max_ms": 297.01, + "duration_p50_ms": 289.91, + "duration_p99_ms": 297.01, + "duration_std_ms": 1.73, + "throughput_avg_mbps": 1540.99, + "throughput_min_mbps": 1508.39, + "throughput_max_mbps": 1549.71, + "ops_per_sec_avg": 110.07, + "latency_per_key_ms": 9.085 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-2.json new file mode 100644 index 0000000..b6ca88c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 342.42, + "duration_min_ms": 327.08, + "duration_max_ms": 350.72, + "duration_p50_ms": 344.83, + "duration_p99_ms": 350.72, + "duration_std_ms": 7.32, + "throughput_avg_mbps": 1308.93, + "throughput_min_mbps": 1277.37, + "throughput_max_mbps": 1369.68, + "ops_per_sec_avg": 93.5, + "latency_per_key_ms": 10.7 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.05, + "duration_max_ms": 1.42, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.42, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25284.38, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 293.29, + "duration_min_ms": 291.45, + "duration_max_ms": 295.98, + "duration_p50_ms": 292.9, + "duration_p99_ms": 295.98, + "duration_std_ms": 1.35, + "throughput_avg_mbps": 1527.54, + "throughput_min_mbps": 1513.6, + "throughput_max_mbps": 1537.13, + "ops_per_sec_avg": 109.11, + "latency_per_key_ms": 9.165 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-3.json new file mode 100644 index 0000000..3f8979f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.86, + "duration_min_ms": 328.47, + "duration_max_ms": 350.85, + "duration_p50_ms": 342.48, + "duration_p99_ms": 350.85, + "duration_std_ms": 6.8, + "throughput_avg_mbps": 1310.96, + "throughput_min_mbps": 1276.91, + "throughput_max_mbps": 1363.92, + "ops_per_sec_avg": 93.64, + "latency_per_key_ms": 10.683 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.12, + "duration_max_ms": 1.5, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.5, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24515.88, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.2, + "duration_min_ms": 289.45, + "duration_max_ms": 298.16, + "duration_p50_ms": 291.39, + "duration_p99_ms": 298.16, + "duration_std_ms": 2.14, + "throughput_avg_mbps": 1533.26, + "throughput_min_mbps": 1502.54, + "throughput_max_mbps": 1547.76, + "ops_per_sec_avg": 109.52, + "latency_per_key_ms": 9.131 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-1.json new file mode 100644 index 0000000..3ed3d47 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.75, + "duration_min_ms": 322.71, + "duration_max_ms": 348.19, + "duration_p50_ms": 345.36, + "duration_p99_ms": 348.19, + "duration_std_ms": 8.86, + "throughput_avg_mbps": 1311.78, + "throughput_min_mbps": 1286.65, + "throughput_max_mbps": 1388.24, + "ops_per_sec_avg": 93.7, + "latency_per_key_ms": 10.68 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.13, + "duration_max_ms": 1.4, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.4, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24917.59, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 308.5, + "duration_min_ms": 305.9, + "duration_max_ms": 312.32, + "duration_p50_ms": 308.2, + "duration_p99_ms": 312.32, + "duration_std_ms": 1.8, + "throughput_avg_mbps": 1452.25, + "throughput_min_mbps": 1434.45, + "throughput_max_mbps": 1464.52, + "ops_per_sec_avg": 103.73, + "latency_per_key_ms": 9.64 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-2.json new file mode 100644 index 0000000..a233fa8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 342.04, + "duration_min_ms": 327.7, + "duration_max_ms": 348.54, + "duration_p50_ms": 345.24, + "duration_p99_ms": 348.54, + "duration_std_ms": 7.37, + "throughput_avg_mbps": 1310.38, + "throughput_min_mbps": 1285.35, + "throughput_max_mbps": 1367.1, + "ops_per_sec_avg": 93.6, + "latency_per_key_ms": 10.689 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.33, + "duration_min_ms": 1.14, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.3, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24120.5, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 308.63, + "duration_min_ms": 305.15, + "duration_max_ms": 312.83, + "duration_p50_ms": 308.69, + "duration_p99_ms": 312.83, + "duration_std_ms": 1.97, + "throughput_avg_mbps": 1451.65, + "throughput_min_mbps": 1432.1, + "throughput_max_mbps": 1468.14, + "ops_per_sec_avg": 103.69, + "latency_per_key_ms": 9.645 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-3.json new file mode 100644 index 0000000..792c1b6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w2-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 342.58, + "duration_min_ms": 323.24, + "duration_max_ms": 358.95, + "duration_p50_ms": 345.26, + "duration_p99_ms": 358.95, + "duration_std_ms": 9.54, + "throughput_avg_mbps": 1308.7, + "throughput_min_mbps": 1248.08, + "throughput_max_mbps": 1385.95, + "ops_per_sec_avg": 93.48, + "latency_per_key_ms": 10.706 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.09, + "duration_max_ms": 1.55, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.55, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24447.9, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 308.69, + "duration_min_ms": 304.46, + "duration_max_ms": 313.02, + "duration_p50_ms": 308.77, + "duration_p99_ms": 313.02, + "duration_std_ms": 1.95, + "throughput_avg_mbps": 1451.33, + "throughput_min_mbps": 1431.2, + "throughput_max_mbps": 1471.44, + "ops_per_sec_avg": 103.67, + "latency_per_key_ms": 9.647 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-1.json new file mode 100644 index 0000000..787dfff --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.23, + "duration_min_ms": 325.01, + "duration_max_ms": 347.85, + "duration_p50_ms": 344.41, + "duration_p99_ms": 347.85, + "duration_std_ms": 7.55, + "throughput_avg_mbps": 1313.52, + "throughput_min_mbps": 1287.89, + "throughput_max_mbps": 1378.43, + "ops_per_sec_avg": 93.82, + "latency_per_key_ms": 10.663 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.11, + "duration_max_ms": 1.49, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.49, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25066.32, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.45, + "duration_min_ms": 289.5, + "duration_max_ms": 296.62, + "duration_p50_ms": 292.47, + "duration_p99_ms": 296.62, + "duration_std_ms": 1.8, + "throughput_avg_mbps": 1531.93, + "throughput_min_mbps": 1510.33, + "throughput_max_mbps": 1547.51, + "ops_per_sec_avg": 109.42, + "latency_per_key_ms": 9.139 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-2.json new file mode 100644 index 0000000..17cb382 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.31, + "duration_min_ms": 325.1, + "duration_max_ms": 348.19, + "duration_p50_ms": 344.86, + "duration_p99_ms": 348.19, + "duration_std_ms": 7.9, + "throughput_avg_mbps": 1313.29, + "throughput_min_mbps": 1286.64, + "throughput_max_mbps": 1378.05, + "ops_per_sec_avg": 93.81, + "latency_per_key_ms": 10.666 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.18, + "duration_max_ms": 1.37, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.37, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25177.7, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.4, + "duration_min_ms": 288.94, + "duration_max_ms": 297.99, + "duration_p50_ms": 292.51, + "duration_p99_ms": 297.99, + "duration_std_ms": 2.09, + "throughput_avg_mbps": 1532.22, + "throughput_min_mbps": 1503.42, + "throughput_max_mbps": 1550.48, + "ops_per_sec_avg": 109.44, + "latency_per_key_ms": 9.138 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-3.json new file mode 100644 index 0000000..4ee2c72 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.35, + "duration_min_ms": 325.95, + "duration_max_ms": 349.33, + "duration_p50_ms": 344.54, + "duration_p99_ms": 349.33, + "duration_std_ms": 7.37, + "throughput_avg_mbps": 1313.02, + "throughput_min_mbps": 1282.44, + "throughput_max_mbps": 1374.44, + "ops_per_sec_avg": 93.79, + "latency_per_key_ms": 10.667 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.33, + "duration_min_ms": 1.16, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24119.79, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.66, + "duration_min_ms": 290.18, + "duration_max_ms": 297.43, + "duration_p50_ms": 292.62, + "duration_p99_ms": 297.43, + "duration_std_ms": 1.96, + "throughput_avg_mbps": 1530.88, + "throughput_min_mbps": 1506.22, + "throughput_max_mbps": 1543.86, + "ops_per_sec_avg": 109.35, + "latency_per_key_ms": 9.145 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-1.json new file mode 100644 index 0000000..d764db4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 420.5, + "duration_min_ms": 403.44, + "duration_max_ms": 431.5, + "duration_p50_ms": 422.04, + "duration_p99_ms": 431.5, + "duration_std_ms": 7.58, + "throughput_avg_mbps": 1065.74, + "throughput_min_mbps": 1038.25, + "throughput_max_mbps": 1110.44, + "ops_per_sec_avg": 76.12, + "latency_per_key_ms": 13.141 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.1, + "duration_max_ms": 1.42, + "duration_p50_ms": 1.33, + "duration_p99_ms": 1.42, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24403.59, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 293.4, + "duration_min_ms": 290.78, + "duration_max_ms": 297.29, + "duration_p50_ms": 293.02, + "duration_p99_ms": 297.29, + "duration_std_ms": 1.92, + "throughput_avg_mbps": 1527.01, + "throughput_min_mbps": 1506.96, + "throughput_max_mbps": 1540.71, + "ops_per_sec_avg": 109.07, + "latency_per_key_ms": 9.169 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-2.json new file mode 100644 index 0000000..24ab478 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 418.49, + "duration_min_ms": 399.4, + "duration_max_ms": 431.18, + "duration_p50_ms": 418.75, + "duration_p99_ms": 431.18, + "duration_std_ms": 8.54, + "throughput_avg_mbps": 1070.95, + "throughput_min_mbps": 1039.0, + "throughput_max_mbps": 1121.68, + "ops_per_sec_avg": 76.5, + "latency_per_key_ms": 13.078 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.09, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25383.07, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 293.77, + "duration_min_ms": 290.18, + "duration_max_ms": 296.78, + "duration_p50_ms": 293.99, + "duration_p99_ms": 296.78, + "duration_std_ms": 1.74, + "throughput_avg_mbps": 1525.04, + "throughput_min_mbps": 1509.53, + "throughput_max_mbps": 1543.89, + "ops_per_sec_avg": 108.93, + "latency_per_key_ms": 9.18 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-3.json new file mode 100644 index 0000000..9ec7eba --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w4_l1unaligned-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 417.92, + "duration_min_ms": 405.44, + "duration_max_ms": 425.07, + "duration_p50_ms": 418.31, + "duration_p99_ms": 425.07, + "duration_std_ms": 6.09, + "throughput_avg_mbps": 1072.19, + "throughput_min_mbps": 1053.93, + "throughput_max_mbps": 1104.98, + "ops_per_sec_avg": 76.58, + "latency_per_key_ms": 13.06 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.3, + "duration_min_ms": 1.18, + "duration_max_ms": 1.44, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.44, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24792.6, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.28, + "duration_min_ms": 290.77, + "duration_max_ms": 294.32, + "duration_p50_ms": 291.83, + "duration_p99_ms": 294.32, + "duration_std_ms": 1.1, + "throughput_avg_mbps": 1532.77, + "throughput_min_mbps": 1522.16, + "throughput_max_mbps": 1540.72, + "ops_per_sec_avg": 109.48, + "latency_per_key_ms": 9.134 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-1.json new file mode 100644 index 0000000..4d3c6b8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 340.75, + "duration_min_ms": 324.14, + "duration_max_ms": 349.85, + "duration_p50_ms": 344.05, + "duration_p99_ms": 349.85, + "duration_std_ms": 8.02, + "throughput_avg_mbps": 1315.48, + "throughput_min_mbps": 1280.54, + "throughput_max_mbps": 1382.1, + "ops_per_sec_avg": 93.96, + "latency_per_key_ms": 10.648 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.12, + "duration_max_ms": 1.39, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.39, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25244.01, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.57, + "duration_min_ms": 288.97, + "duration_max_ms": 293.91, + "duration_p50_ms": 291.28, + "duration_p99_ms": 293.91, + "duration_std_ms": 1.32, + "throughput_avg_mbps": 1536.56, + "throughput_min_mbps": 1524.26, + "throughput_max_mbps": 1550.35, + "ops_per_sec_avg": 109.75, + "latency_per_key_ms": 9.111 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-2.json new file mode 100644 index 0000000..624c7e0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.16, + "duration_min_ms": 323.35, + "duration_max_ms": 347.37, + "duration_p50_ms": 343.11, + "duration_p99_ms": 347.37, + "duration_std_ms": 7.55, + "throughput_avg_mbps": 1313.8, + "throughput_min_mbps": 1289.69, + "throughput_max_mbps": 1385.51, + "ops_per_sec_avg": 93.84, + "latency_per_key_ms": 10.661 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.14, + "duration_max_ms": 1.5, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.5, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24987.89, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.41, + "duration_min_ms": 289.25, + "duration_max_ms": 304.25, + "duration_p50_ms": 291.58, + "duration_p99_ms": 304.25, + "duration_std_ms": 3.32, + "throughput_avg_mbps": 1532.28, + "throughput_min_mbps": 1472.48, + "throughput_max_mbps": 1548.86, + "ops_per_sec_avg": 109.45, + "latency_per_key_ms": 9.138 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-3.json new file mode 100644 index 0000000..04fd5fc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/hypercache_raw_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.88, + "duration_min_ms": 324.7, + "duration_max_ms": 348.38, + "duration_p50_ms": 344.24, + "duration_p99_ms": 348.38, + "duration_std_ms": 6.81, + "throughput_avg_mbps": 1310.92, + "throughput_min_mbps": 1285.94, + "throughput_max_mbps": 1379.75, + "ops_per_sec_avg": 93.64, + "latency_per_key_ms": 10.684 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.15, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24553.39, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.56, + "duration_min_ms": 290.85, + "duration_max_ms": 297.58, + "duration_p50_ms": 292.08, + "duration_p99_ms": 297.58, + "duration_std_ms": 1.51, + "throughput_avg_mbps": 1531.37, + "throughput_min_mbps": 1505.48, + "throughput_max_mbps": 1540.32, + "ops_per_sec_avg": 109.38, + "latency_per_key_ms": 9.142 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-1.json new file mode 100644 index 0000000..54016fc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 327.63, + "duration_min_ms": 310.99, + "duration_max_ms": 334.33, + "duration_p50_ms": 330.04, + "duration_p99_ms": 334.33, + "duration_std_ms": 7.7, + "throughput_avg_mbps": 1368.12, + "throughput_min_mbps": 1340.01, + "throughput_max_mbps": 1440.54, + "ops_per_sec_avg": 97.72, + "latency_per_key_ms": 10.239 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.21, + "duration_max_ms": 0.37, + "duration_p50_ms": 0.23, + "duration_p99_ms": 0.37, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 131811.56, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.33, + "duration_min_ms": 288.92, + "duration_max_ms": 294.58, + "duration_p50_ms": 290.88, + "duration_p99_ms": 294.58, + "duration_std_ms": 1.61, + "throughput_avg_mbps": 1537.82, + "throughput_min_mbps": 1520.79, + "throughput_max_mbps": 1550.61, + "ops_per_sec_avg": 109.84, + "latency_per_key_ms": 9.104 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-2.json new file mode 100644 index 0000000..0b8b75b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 329.48, + "duration_min_ms": 310.03, + "duration_max_ms": 372.89, + "duration_p50_ms": 330.86, + "duration_p99_ms": 372.89, + "duration_std_ms": 13.34, + "throughput_avg_mbps": 1361.75, + "throughput_min_mbps": 1201.43, + "throughput_max_mbps": 1445.01, + "ops_per_sec_avg": 97.27, + "latency_per_key_ms": 10.296 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.27, + "duration_min_ms": 0.19, + "duration_max_ms": 0.41, + "duration_p50_ms": 0.25, + "duration_p99_ms": 0.41, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 124408.82, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.36, + "duration_min_ms": 290.13, + "duration_max_ms": 303.18, + "duration_p50_ms": 291.34, + "duration_p99_ms": 303.18, + "duration_std_ms": 2.93, + "throughput_avg_mbps": 1532.52, + "throughput_min_mbps": 1477.65, + "throughput_max_mbps": 1544.15, + "ops_per_sec_avg": 109.47, + "latency_per_key_ms": 9.136 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-3.json new file mode 100644 index 0000000..2a72a5e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6-odirect/raw_block_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 327.85, + "duration_min_ms": 309.96, + "duration_max_ms": 334.31, + "duration_p50_ms": 330.64, + "duration_p99_ms": 334.31, + "duration_std_ms": 7.45, + "throughput_avg_mbps": 1367.17, + "throughput_min_mbps": 1340.07, + "throughput_max_mbps": 1445.35, + "ops_per_sec_avg": 97.65, + "latency_per_key_ms": 10.245 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.24, + "duration_min_ms": 0.18, + "duration_max_ms": 0.32, + "duration_p50_ms": 0.24, + "duration_p99_ms": 0.32, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 135187.74, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.31, + "duration_min_ms": 289.73, + "duration_max_ms": 293.85, + "duration_p50_ms": 291.0, + "duration_p99_ms": 293.85, + "duration_std_ms": 1.38, + "throughput_avg_mbps": 1537.93, + "throughput_min_mbps": 1524.58, + "throughput_max_mbps": 1546.29, + "ops_per_sec_avg": 109.85, + "latency_per_key_ms": 9.103 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-1.json new file mode 100644 index 0000000..964c8aa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 336.55, + "duration_min_ms": 319.19, + "duration_max_ms": 343.81, + "duration_p50_ms": 339.57, + "duration_p99_ms": 343.81, + "duration_std_ms": 7.57, + "throughput_avg_mbps": 1331.81, + "throughput_min_mbps": 1303.03, + "throughput_max_mbps": 1403.54, + "ops_per_sec_avg": 95.13, + "latency_per_key_ms": 10.517 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.19, + "duration_min_ms": 0.09, + "duration_max_ms": 0.39, + "duration_p50_ms": 0.12, + "duration_p99_ms": 0.39, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 207726.28, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 296.13, + "duration_min_ms": 294.28, + "duration_max_ms": 301.55, + "duration_p50_ms": 295.95, + "duration_p99_ms": 301.55, + "duration_std_ms": 1.64, + "throughput_avg_mbps": 1512.89, + "throughput_min_mbps": 1485.63, + "throughput_max_mbps": 1522.34, + "ops_per_sec_avg": 108.06, + "latency_per_key_ms": 9.254 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-2.json new file mode 100644 index 0000000..b6f30ed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 337.99, + "duration_min_ms": 320.97, + "duration_max_ms": 377.22, + "duration_p50_ms": 339.43, + "duration_p99_ms": 377.22, + "duration_std_ms": 11.96, + "throughput_avg_mbps": 1326.98, + "throughput_min_mbps": 1187.63, + "throughput_max_mbps": 1395.75, + "ops_per_sec_avg": 94.78, + "latency_per_key_ms": 10.562 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.17, + "duration_min_ms": 0.1, + "duration_max_ms": 0.38, + "duration_p50_ms": 0.11, + "duration_p99_ms": 0.38, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 232984.42, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 296.16, + "duration_min_ms": 293.64, + "duration_max_ms": 301.82, + "duration_p50_ms": 295.8, + "duration_p99_ms": 301.82, + "duration_std_ms": 1.92, + "throughput_avg_mbps": 1512.78, + "throughput_min_mbps": 1484.35, + "throughput_max_mbps": 1525.65, + "ops_per_sec_avg": 108.06, + "latency_per_key_ms": 9.255 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-3.json new file mode 100644 index 0000000..34d32f9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/fs_native_odirect-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/mnt/test/fs\",\"use_odirect\":true}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 338.23, + "duration_min_ms": 321.62, + "duration_max_ms": 344.71, + "duration_p50_ms": 341.13, + "duration_p99_ms": 344.71, + "duration_std_ms": 7.39, + "throughput_avg_mbps": 1325.17, + "throughput_min_mbps": 1299.65, + "throughput_max_mbps": 1392.96, + "ops_per_sec_avg": 94.65, + "latency_per_key_ms": 10.57 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.17, + "duration_min_ms": 0.09, + "duration_max_ms": 0.37, + "duration_p50_ms": 0.13, + "duration_p99_ms": 0.37, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 217752.71, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 297.13, + "duration_min_ms": 293.78, + "duration_max_ms": 302.07, + "duration_p50_ms": 297.08, + "duration_p99_ms": 302.07, + "duration_std_ms": 2.29, + "throughput_avg_mbps": 1507.86, + "throughput_min_mbps": 1483.11, + "throughput_max_mbps": 1524.93, + "ops_per_sec_avg": 107.7, + "latency_per_key_ms": 9.285 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-1.json new file mode 100644 index 0000000..85fd850 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 495.49, + "duration_min_ms": 471.06, + "duration_max_ms": 520.7, + "duration_p50_ms": 497.03, + "duration_p99_ms": 520.7, + "duration_std_ms": 11.06, + "throughput_avg_mbps": 904.58, + "throughput_min_mbps": 860.38, + "throughput_max_mbps": 951.04, + "ops_per_sec_avg": 64.61, + "latency_per_key_ms": 15.484 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.3, + "duration_min_ms": 1.15, + "duration_max_ms": 1.46, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.46, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24620.16, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 314.83, + "duration_min_ms": 310.65, + "duration_max_ms": 319.1, + "duration_p50_ms": 313.66, + "duration_p99_ms": 319.1, + "duration_std_ms": 2.82, + "throughput_avg_mbps": 1423.1, + "throughput_min_mbps": 1403.95, + "throughput_max_mbps": 1442.16, + "ops_per_sec_avg": 101.65, + "latency_per_key_ms": 9.838 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-2.json new file mode 100644 index 0000000..ff743a5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 494.02, + "duration_min_ms": 475.31, + "duration_max_ms": 503.3, + "duration_p50_ms": 496.62, + "duration_p99_ms": 503.3, + "duration_std_ms": 7.84, + "throughput_avg_mbps": 907.07, + "throughput_min_mbps": 890.12, + "throughput_max_mbps": 942.54, + "ops_per_sec_avg": 64.79, + "latency_per_key_ms": 15.438 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.16, + "duration_max_ms": 1.44, + "duration_p50_ms": 1.31, + "duration_p99_ms": 1.44, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24345.79, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 318.23, + "duration_min_ms": 312.4, + "duration_max_ms": 339.61, + "duration_p50_ms": 316.11, + "duration_p99_ms": 339.61, + "duration_std_ms": 5.83, + "throughput_avg_mbps": 1408.23, + "throughput_min_mbps": 1319.15, + "throughput_max_mbps": 1434.06, + "ops_per_sec_avg": 100.59, + "latency_per_key_ms": 9.945 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-3.json new file mode 100644 index 0000000..085c581 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w2-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":2}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 494.53, + "duration_min_ms": 475.24, + "duration_max_ms": 505.4, + "duration_p50_ms": 497.83, + "duration_p99_ms": 505.4, + "duration_std_ms": 8.48, + "throughput_avg_mbps": 906.17, + "throughput_min_mbps": 886.43, + "throughput_max_mbps": 942.68, + "ops_per_sec_avg": 64.73, + "latency_per_key_ms": 15.454 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.32, + "duration_min_ms": 1.13, + "duration_max_ms": 1.7, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.7, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24425.64, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 314.24, + "duration_min_ms": 310.37, + "duration_max_ms": 320.79, + "duration_p50_ms": 313.87, + "duration_p99_ms": 320.79, + "duration_std_ms": 2.74, + "throughput_avg_mbps": 1425.76, + "throughput_min_mbps": 1396.54, + "throughput_max_mbps": 1443.43, + "ops_per_sec_avg": 101.84, + "latency_per_key_ms": 9.82 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-1.json new file mode 100644 index 0000000..9f00be1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 408.32, + "duration_min_ms": 390.25, + "duration_max_ms": 416.87, + "duration_p50_ms": 411.85, + "duration_p99_ms": 416.87, + "duration_std_ms": 8.37, + "throughput_avg_mbps": 1097.62, + "throughput_min_mbps": 1074.68, + "throughput_max_mbps": 1147.99, + "ops_per_sec_avg": 78.4, + "latency_per_key_ms": 12.76 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.14, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24497.06, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 322.31, + "duration_min_ms": 314.11, + "duration_max_ms": 330.58, + "duration_p50_ms": 322.32, + "duration_p99_ms": 330.58, + "duration_std_ms": 4.76, + "throughput_avg_mbps": 1390.24, + "throughput_min_mbps": 1355.21, + "throughput_max_mbps": 1426.27, + "ops_per_sec_avg": 99.3, + "latency_per_key_ms": 10.072 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-2.json new file mode 100644 index 0000000..45b1a30 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 409.35, + "duration_min_ms": 390.08, + "duration_max_ms": 434.74, + "duration_p50_ms": 411.38, + "duration_p99_ms": 434.74, + "duration_std_ms": 10.15, + "throughput_avg_mbps": 1095.05, + "throughput_min_mbps": 1030.49, + "throughput_max_mbps": 1148.49, + "ops_per_sec_avg": 78.22, + "latency_per_key_ms": 12.792 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.13, + "duration_max_ms": 1.51, + "duration_p50_ms": 1.24, + "duration_p99_ms": 1.51, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25321.54, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 325.82, + "duration_min_ms": 314.71, + "duration_max_ms": 336.25, + "duration_p50_ms": 325.24, + "duration_p99_ms": 336.25, + "duration_std_ms": 5.66, + "throughput_avg_mbps": 1375.37, + "throughput_min_mbps": 1332.34, + "throughput_max_mbps": 1423.55, + "ops_per_sec_avg": 98.24, + "latency_per_key_ms": 10.182 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-3.json new file mode 100644 index 0000000..c530a87 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 408.18, + "duration_min_ms": 389.59, + "duration_max_ms": 416.48, + "duration_p50_ms": 411.57, + "duration_p99_ms": 416.48, + "duration_std_ms": 9.07, + "throughput_avg_mbps": 1098.1, + "throughput_min_mbps": 1075.67, + "throughput_max_mbps": 1149.93, + "ops_per_sec_avg": 78.44, + "latency_per_key_ms": 12.755 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.14, + "duration_max_ms": 1.55, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.55, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24912.26, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 321.52, + "duration_min_ms": 312.68, + "duration_max_ms": 328.44, + "duration_p50_ms": 322.01, + "duration_p99_ms": 328.44, + "duration_std_ms": 4.45, + "throughput_avg_mbps": 1393.65, + "throughput_min_mbps": 1364.03, + "throughput_max_mbps": 1432.76, + "ops_per_sec_avg": 99.55, + "latency_per_key_ms": 10.047 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-1.json new file mode 100644 index 0000000..3d3c22a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 396.26, + "duration_min_ms": 373.06, + "duration_max_ms": 405.84, + "duration_p50_ms": 398.89, + "duration_p99_ms": 405.84, + "duration_std_ms": 9.81, + "throughput_avg_mbps": 1131.24, + "throughput_min_mbps": 1103.89, + "throughput_max_mbps": 1200.88, + "ops_per_sec_avg": 80.8, + "latency_per_key_ms": 12.383 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.09, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25386.14, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 392.14, + "duration_min_ms": 376.63, + "duration_max_ms": 405.15, + "duration_p50_ms": 393.1, + "duration_p99_ms": 405.15, + "duration_std_ms": 8.57, + "throughput_avg_mbps": 1142.97, + "throughput_min_mbps": 1105.77, + "throughput_max_mbps": 1189.49, + "ops_per_sec_avg": 81.64, + "latency_per_key_ms": 12.254 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-2.json new file mode 100644 index 0000000..223d78c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 397.72, + "duration_min_ms": 382.62, + "duration_max_ms": 411.37, + "duration_p50_ms": 399.58, + "duration_p99_ms": 411.37, + "duration_std_ms": 7.51, + "throughput_avg_mbps": 1126.8, + "throughput_min_mbps": 1089.05, + "throughput_max_mbps": 1170.89, + "ops_per_sec_avg": 80.49, + "latency_per_key_ms": 12.429 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.04, + "duration_max_ms": 1.53, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.53, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25115.03, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 391.85, + "duration_min_ms": 377.98, + "duration_max_ms": 408.65, + "duration_p50_ms": 390.78, + "duration_p99_ms": 408.65, + "duration_std_ms": 6.62, + "throughput_avg_mbps": 1143.61, + "throughput_min_mbps": 1096.3, + "throughput_max_mbps": 1185.25, + "ops_per_sec_avg": 81.69, + "latency_per_key_ms": 12.245 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-3.json new file mode 100644 index 0000000..dea0aa4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/hypercache_raw_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 398.53, + "duration_min_ms": 378.0, + "duration_max_ms": 407.45, + "duration_p50_ms": 400.72, + "duration_p99_ms": 407.45, + "duration_std_ms": 8.51, + "throughput_avg_mbps": 1124.64, + "throughput_min_mbps": 1099.53, + "throughput_max_mbps": 1185.18, + "ops_per_sec_avg": 80.33, + "latency_per_key_ms": 12.454 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.22, + "duration_min_ms": 0.99, + "duration_max_ms": 1.36, + "duration_p50_ms": 1.25, + "duration_p99_ms": 1.36, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 26328.2, + "latency_per_key_ms": 0.038 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 391.93, + "duration_min_ms": 376.22, + "duration_max_ms": 409.92, + "duration_p50_ms": 391.97, + "duration_p99_ms": 409.92, + "duration_std_ms": 8.5, + "throughput_avg_mbps": 1143.56, + "throughput_min_mbps": 1092.9, + "throughput_max_mbps": 1190.8, + "ops_per_sec_avg": 81.68, + "latency_per_key_ms": 12.248 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-1.json new file mode 100644 index 0000000..3eadc76 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 350.24, + "duration_min_ms": 314.59, + "duration_max_ms": 752.92, + "duration_p50_ms": 332.37, + "duration_p99_ms": 752.92, + "duration_std_ms": 95.05, + "throughput_avg_mbps": 1323.83, + "throughput_min_mbps": 595.01, + "throughput_max_mbps": 1424.07, + "ops_per_sec_avg": 94.56, + "latency_per_key_ms": 10.945 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.23, + "duration_min_ms": 0.2, + "duration_max_ms": 0.31, + "duration_p50_ms": 0.22, + "duration_p99_ms": 0.31, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 140339.91, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.49, + "duration_min_ms": 289.47, + "duration_max_ms": 294.25, + "duration_p50_ms": 291.39, + "duration_p99_ms": 294.25, + "duration_std_ms": 1.3, + "throughput_avg_mbps": 1536.95, + "throughput_min_mbps": 1522.51, + "throughput_max_mbps": 1547.67, + "ops_per_sec_avg": 109.78, + "latency_per_key_ms": 9.109 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-2.json new file mode 100644 index 0000000..6b58fb6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 328.87, + "duration_min_ms": 314.48, + "duration_max_ms": 336.49, + "duration_p50_ms": 331.46, + "duration_p99_ms": 336.49, + "duration_std_ms": 7.37, + "throughput_avg_mbps": 1362.91, + "throughput_min_mbps": 1331.37, + "throughput_max_mbps": 1424.59, + "ops_per_sec_avg": 97.35, + "latency_per_key_ms": 10.277 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.26, + "duration_min_ms": 0.22, + "duration_max_ms": 0.4, + "duration_p50_ms": 0.24, + "duration_p99_ms": 0.4, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 128732.28, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.04, + "duration_min_ms": 289.92, + "duration_max_ms": 298.09, + "duration_p50_ms": 291.67, + "duration_p99_ms": 298.09, + "duration_std_ms": 1.75, + "throughput_avg_mbps": 1534.11, + "throughput_min_mbps": 1502.92, + "throughput_max_mbps": 1545.26, + "ops_per_sec_avg": 109.58, + "latency_per_key_ms": 9.126 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-3.json new file mode 100644 index 0000000..641e4a3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_default-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 348.63, + "duration_min_ms": 309.82, + "duration_max_ms": 732.4, + "duration_p50_ms": 332.38, + "duration_p99_ms": 732.4, + "duration_std_ms": 90.74, + "throughput_avg_mbps": 1327.38, + "throughput_min_mbps": 611.69, + "throughput_max_mbps": 1446.02, + "ops_per_sec_avg": 94.81, + "latency_per_key_ms": 10.895 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.23, + "duration_min_ms": 0.17, + "duration_max_ms": 0.31, + "duration_p50_ms": 0.22, + "duration_p99_ms": 0.31, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 142396.98, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.72, + "duration_min_ms": 290.22, + "duration_max_ms": 300.25, + "duration_p50_ms": 291.71, + "duration_p99_ms": 300.25, + "duration_std_ms": 2.61, + "throughput_avg_mbps": 1530.57, + "throughput_min_mbps": 1492.11, + "throughput_max_mbps": 1543.67, + "ops_per_sec_avg": 109.33, + "latency_per_key_ms": 9.148 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-1.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-1.json new file mode 100644 index 0000000..8bf9f47 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 328.07, + "duration_min_ms": 311.65, + "duration_max_ms": 334.24, + "duration_p50_ms": 329.98, + "duration_p99_ms": 334.24, + "duration_std_ms": 6.66, + "throughput_avg_mbps": 1366.13, + "throughput_min_mbps": 1340.36, + "throughput_max_mbps": 1437.51, + "ops_per_sec_avg": 97.58, + "latency_per_key_ms": 10.252 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.24, + "duration_min_ms": 0.17, + "duration_max_ms": 0.3, + "duration_p50_ms": 0.23, + "duration_p99_ms": 0.3, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 138463.31, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.02, + "duration_min_ms": 289.29, + "duration_max_ms": 299.08, + "duration_p50_ms": 291.74, + "duration_p99_ms": 299.08, + "duration_std_ms": 2.02, + "throughput_avg_mbps": 1534.19, + "throughput_min_mbps": 1497.93, + "throughput_max_mbps": 1548.61, + "ops_per_sec_avg": 109.58, + "latency_per_key_ms": 9.126 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-2.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-2.json new file mode 100644 index 0000000..7ed6799 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 327.5, + "duration_min_ms": 311.92, + "duration_max_ms": 335.33, + "duration_p50_ms": 330.38, + "duration_p99_ms": 335.33, + "duration_std_ms": 7.7, + "throughput_avg_mbps": 1368.69, + "throughput_min_mbps": 1336.0, + "throughput_max_mbps": 1436.29, + "ops_per_sec_avg": 97.76, + "latency_per_key_ms": 10.234 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.21, + "duration_max_ms": 0.31, + "duration_p50_ms": 0.23, + "duration_p99_ms": 0.31, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 130913.15, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.52, + "duration_min_ms": 289.29, + "duration_max_ms": 302.28, + "duration_p50_ms": 291.41, + "duration_p99_ms": 302.28, + "duration_std_ms": 3.13, + "throughput_avg_mbps": 1531.7, + "throughput_min_mbps": 1482.08, + "throughput_max_mbps": 1548.64, + "ops_per_sec_avg": 109.41, + "latency_per_key_ms": 9.141 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-3.json b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-3.json new file mode 100644 index 0000000..151f9d9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/lmcache-0.5.6/raw_block_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 329.36, + "duration_min_ms": 313.17, + "duration_max_ms": 353.63, + "duration_p50_ms": 330.69, + "duration_p99_ms": 353.63, + "duration_std_ms": 9.06, + "throughput_avg_mbps": 1361.2, + "throughput_min_mbps": 1266.86, + "throughput_max_mbps": 1430.54, + "ops_per_sec_avg": 97.23, + "latency_per_key_ms": 10.292 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.27, + "duration_min_ms": 0.19, + "duration_max_ms": 0.39, + "duration_p50_ms": 0.27, + "duration_p99_ms": 0.39, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 123321.49, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.86, + "duration_min_ms": 290.24, + "duration_max_ms": 294.84, + "duration_p50_ms": 291.69, + "duration_p99_ms": 294.84, + "duration_std_ms": 1.21, + "throughput_avg_mbps": 1535.02, + "throughput_min_mbps": 1519.45, + "throughput_max_mbps": 1543.54, + "ops_per_sec_avg": 109.64, + "latency_per_key_ms": 9.121 + } + } +} diff --git a/benchmarks/results/pipelined_ttft.json b/benchmarks/results/pipelined_ttft.json new file mode 100644 index 0000000..b1cd197 --- /dev/null +++ b/benchmarks/results/pipelined_ttft.json @@ -0,0 +1,190 @@ +{ + "machine": { + "device": "cuda", + "gpu": "NVIDIA GeForce RTX 4060 Ti, 16380 MiB", + "cpu_count": 12, + "torch": "2.13.0+cu130", + "python": "3.12.3", + "kernel": "6.8.0-147-generic" + }, + "model": "a09a35458c702b33eeacc393d103063234e8bc28", + "object_bytes": 15231233024, + "repeats": 3, + "prefetch_ahead": 2, + "results": [ + { + "prompt_tokens": 5, + "next_token": " Paris", + "tokens_match": true, + "first_layer_ms": 880.3474130108953, + "t_io_s": 15.06471174606122, + "t_compute_s": 0.05562613089568913, + "eager_ttft_s": 15.141310456907377, + "pipelined_ttft_s": 15.658677583094686, + "raw": { + "eager": [ + { + "token": 12095, + "first_layer_s": 1.2573820089455694, + "t_io_s": 15.050846588797867, + "ttft_s": 16.5194000788033, + "t_compute_s": 0.056270692963153124 + }, + { + "token": 12095, + "first_layer_s": 1.3267928650602698, + "t_io_s": 15.06471174606122, + "ttft_s": 15.121124816127121, + "t_compute_s": 0.05562613089568913 + }, + { + "token": 12095, + "first_layer_s": 1.2536415059585124, + "t_io_s": 15.085030868882313, + "ttft_s": 15.141310456907377, + "t_compute_s": 0.05560304690152407 + } + ], + "pipelined": [ + { + "token": 12095, + "first_layer_s": 0.8772531421855092, + "ttft_s": 15.658677583094686, + "weight_wait_s": 11.655349807115272 + }, + { + "token": 12095, + "first_layer_s": 0.8843183449935168, + "ttft_s": 15.679330268176273, + "weight_wait_s": 11.550516932737082 + }, + { + "token": 12095, + "first_layer_s": 0.8803474130108953, + "ttft_s": 15.658374320017174, + "weight_wait_s": 11.682787736877799 + } + ] + }, + "saving_s": -0.5173671261873096, + "saving_pct": -3.416924365032683, + "bound_s": 0.05562613089568913 + }, + { + "prompt_tokens": 2048, + "next_token": " dog", + "tokens_match": true, + "first_layer_ms": 878.1645318958908, + "t_io_s": 15.164180933963507, + "t_compute_s": 0.700582010904327, + "eager_ttft_s": 15.87739925715141, + "pipelined_ttft_s": 16.073160496074706, + "raw": { + "eager": [ + { + "token": 5562, + "first_layer_s": 1.3290932248346508, + "t_io_s": 15.164180933963507, + "ttft_s": 15.943666161969304, + "t_compute_s": 0.7006052711512893 + }, + { + "token": 5562, + "first_layer_s": 1.600353023968637, + "t_io_s": 15.176279403967783, + "ttft_s": 15.87739925715141, + "t_compute_s": 0.700582010904327 + }, + { + "token": 5562, + "first_layer_s": 1.2458412188570946, + "t_io_s": 15.083936739014462, + "ttft_s": 15.783995353849605, + "t_compute_s": 0.7005484439432621 + } + ], + "pipelined": [ + { + "token": 5562, + "first_layer_s": 0.8777075631078333, + "ttft_s": 16.05673292116262, + "weight_wait_s": 12.218721500365064 + }, + { + "token": 5562, + "first_layer_s": 0.8781645318958908, + "ttft_s": 16.073160496074706, + "weight_wait_s": 11.99401595001109 + }, + { + "token": 5562, + "first_layer_s": 0.8799337379168719, + "ttft_s": 16.095904150046408, + "weight_wait_s": 11.910986011149362 + } + ] + }, + "saving_s": -0.19576123892329633, + "saving_pct": -1.2329553206588455, + "bound_s": 0.700582010904327 + }, + { + "prompt_tokens": 4096, + "next_token": " quick", + "tokens_match": true, + "first_layer_ms": 881.3357539474964, + "t_io_s": 15.208280224120244, + "t_compute_s": 1.4646139510441571, + "eager_ttft_s": 16.673093752004206, + "pipelined_ttft_s": 16.48826220491901, + "raw": { + "eager": [ + { + "token": 3974, + "first_layer_s": 1.6070972089655697, + "t_io_s": 15.246490160934627, + "ttft_s": 16.70907884812914, + "t_compute_s": 1.4646139510441571 + }, + { + "token": 3974, + "first_layer_s": 1.344985238974914, + "t_io_s": 15.208280224120244, + "ttft_s": 16.673093752004206, + "t_compute_s": 1.4647588450461626 + }, + { + "token": 3974, + "first_layer_s": 1.234419298125431, + "t_io_s": 15.01229586219415, + "ttft_s": 16.47445929609239, + "t_compute_s": 1.461973707191646 + } + ], + "pipelined": [ + { + "token": 3974, + "first_layer_s": 0.8813357539474964, + "ttft_s": 16.48826220491901, + "weight_wait_s": 12.585765631170943 + }, + { + "token": 3974, + "first_layer_s": 0.8817324130795896, + "ttft_s": 16.419657428981736, + "weight_wait_s": 12.573977639665827 + }, + { + "token": 3974, + "first_layer_s": 0.8803776130080223, + "ttft_s": 16.625652038957924, + "weight_wait_s": 12.755885315360501 + } + ] + }, + "saving_s": 0.18483154708519578, + "saving_pct": 1.1085617932363507, + "bound_s": 1.4646139510441571 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/raw_write_probe.jsonl b/benchmarks/results/raw_write_probe.jsonl new file mode 100644 index 0000000..c1da373 --- /dev/null +++ b/benchmarks/results/raw_write_probe.jsonl @@ -0,0 +1,39 @@ +1 {"mode": "pool", "direct": false, "parallel": 4, "write_mbps": 1114, "read_mbps": 1406, "commit_ms_median": 38.9, "commit_ms_p99": 61.9, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": false, "parallel": 8, "write_mbps": 1090, "read_mbps": 1183, "commit_ms_median": 80.2, "commit_ms_p99": 122.0, "reader_fallbacks": 0} +1 {"mode": "pool", "direct": false, "parallel": 16, "write_mbps": 1221, "read_mbps": 1134, "commit_ms_median": 158.4, "commit_ms_p99": 194.5, "reader_fallbacks": 0} +1 {"mode": "inorder", "direct": true, "parallel": 8, "write_mbps": 1401, "read_mbps": 1606, "commit_ms_median": 13.1, "commit_ms_p99": 40.4, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": true, "parallel": 4, "write_mbps": 1381, "read_mbps": 1605, "commit_ms_median": 15.6, "commit_ms_p99": 36.0, "reader_fallbacks": 0} +1 {"mode": "pool", "direct": false, "parallel": 8, "write_mbps": 1182, "read_mbps": 1211, "commit_ms_median": 78.3, "commit_ms_p99": 135.5, "reader_fallbacks": 0} +1 {"mode": "pool", "direct": false, "parallel": 1, "write_mbps": 816, "read_mbps": 1616, "commit_ms_median": 10.4, "commit_ms_p99": 29.0, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": true, "parallel": 16, "write_mbps": 1394, "read_mbps": 1616, "commit_ms_median": 63.7, "commit_ms_p99": 223.7, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": false, "parallel": 4, "write_mbps": 1036, "read_mbps": 1426, "commit_ms_median": 40.2, "commit_ms_p99": 61.3, "reader_fallbacks": 0} +1 {"mode": "pool", "direct": true, "parallel": 8, "write_mbps": 1297, "read_mbps": 1604, "commit_ms_median": 19.3, "commit_ms_p99": 45.1, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": true, "parallel": 1, "write_mbps": 1006, "read_mbps": 1599, "commit_ms_median": 0.4, "commit_ms_p99": 0.8, "reader_fallbacks": 0} +1 {"mode": "merged", "direct": true, "parallel": 8, "write_mbps": 1393, "read_mbps": 1600, "commit_ms_median": 31.0, "commit_ms_p99": 89.6, "reader_fallbacks": 0} +1 {"mode": "inorder", "direct": false, "parallel": 8, "write_mbps": 1089, "read_mbps": 1175, "commit_ms_median": 80.2, "commit_ms_p99": 124.5, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": true, "parallel": 16, "write_mbps": 1400, "read_mbps": 1615, "commit_ms_median": 57.6, "commit_ms_p99": 254.1, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": false, "parallel": 8, "write_mbps": 1095, "read_mbps": 1177, "commit_ms_median": 80.4, "commit_ms_p99": 141.0, "reader_fallbacks": 0} +2 {"mode": "pool", "direct": false, "parallel": 16, "write_mbps": 1210, "read_mbps": 1133, "commit_ms_median": 158.1, "commit_ms_p99": 204.0, "reader_fallbacks": 0} +2 {"mode": "inorder", "direct": true, "parallel": 8, "write_mbps": 1394, "read_mbps": 1614, "commit_ms_median": 13.6, "commit_ms_p99": 38.0, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": false, "parallel": 4, "write_mbps": 1037, "read_mbps": 1428, "commit_ms_median": 40.1, "commit_ms_p99": 61.7, "reader_fallbacks": 0} +2 {"mode": "pool", "direct": false, "parallel": 4, "write_mbps": 1112, "read_mbps": 1426, "commit_ms_median": 39.1, "commit_ms_p99": 61.3, "reader_fallbacks": 0} +2 {"mode": "pool", "direct": false, "parallel": 1, "write_mbps": 817, "read_mbps": 1616, "commit_ms_median": 10.4, "commit_ms_p99": 29.1, "reader_fallbacks": 0} +2 {"mode": "pool", "direct": false, "parallel": 8, "write_mbps": 1189, "read_mbps": 1214, "commit_ms_median": 77.4, "commit_ms_p99": 115.7, "reader_fallbacks": 0} +2 {"mode": "pool", "direct": true, "parallel": 8, "write_mbps": 1385, "read_mbps": 1624, "commit_ms_median": 20.1, "commit_ms_p99": 49.4, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": true, "parallel": 4, "write_mbps": 1387, "read_mbps": 1600, "commit_ms_median": 14.8, "commit_ms_p99": 40.5, "reader_fallbacks": 0} +2 {"mode": "inorder", "direct": false, "parallel": 8, "write_mbps": 1090, "read_mbps": 1178, "commit_ms_median": 80.7, "commit_ms_p99": 136.1, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": true, "parallel": 1, "write_mbps": 1002, "read_mbps": 1613, "commit_ms_median": 0.4, "commit_ms_p99": 0.8, "reader_fallbacks": 0} +2 {"mode": "merged", "direct": true, "parallel": 8, "write_mbps": 1379, "read_mbps": 1610, "commit_ms_median": 31.4, "commit_ms_p99": 86.7, "reader_fallbacks": 0} +3 {"mode": "pool", "direct": false, "parallel": 16, "write_mbps": 1215, "read_mbps": 1147, "commit_ms_median": 156.7, "commit_ms_p99": 213.2, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": false, "parallel": 8, "write_mbps": 1090, "read_mbps": 1188, "commit_ms_median": 81.0, "commit_ms_p99": 124.3, "reader_fallbacks": 0} +3 {"mode": "pool", "direct": false, "parallel": 8, "write_mbps": 1191, "read_mbps": 1228, "commit_ms_median": 77.3, "commit_ms_p99": 117.6, "reader_fallbacks": 0} +3 {"mode": "inorder", "direct": true, "parallel": 8, "write_mbps": 1392, "read_mbps": 1611, "commit_ms_median": 13.0, "commit_ms_p99": 38.1, "reader_fallbacks": 0} +3 {"mode": "pool", "direct": false, "parallel": 4, "write_mbps": 1115, "read_mbps": 1420, "commit_ms_median": 38.6, "commit_ms_p99": 64.0, "reader_fallbacks": 0} +3 {"mode": "pool", "direct": true, "parallel": 8, "write_mbps": 1363, "read_mbps": 1604, "commit_ms_median": 19.5, "commit_ms_p99": 49.6, "reader_fallbacks": 0} +3 {"mode": "pool", "direct": false, "parallel": 1, "write_mbps": 818, "read_mbps": 1615, "commit_ms_median": 10.4, "commit_ms_p99": 31.9, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": true, "parallel": 16, "write_mbps": 1394, "read_mbps": 1625, "commit_ms_median": 57.9, "commit_ms_p99": 228.8, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": false, "parallel": 4, "write_mbps": 1036, "read_mbps": 1442, "commit_ms_median": 40.1, "commit_ms_p99": 62.6, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": true, "parallel": 4, "write_mbps": 1388, "read_mbps": 1618, "commit_ms_median": 15.5, "commit_ms_p99": 44.4, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": true, "parallel": 8, "write_mbps": 1392, "read_mbps": 1616, "commit_ms_median": 30.4, "commit_ms_p99": 88.9, "reader_fallbacks": 0} +3 {"mode": "inorder", "direct": false, "parallel": 8, "write_mbps": 1089, "read_mbps": 1174, "commit_ms_median": 80.6, "commit_ms_p99": 122.2, "reader_fallbacks": 0} +3 {"mode": "merged", "direct": true, "parallel": 1, "write_mbps": 993, "read_mbps": 1616, "commit_ms_median": 0.4, "commit_ms_p99": 0.8, "reader_fallbacks": 0} diff --git a/benchmarks/write_concurrency_probe.py b/benchmarks/write_concurrency_probe.py new file mode 100644 index 0000000..818c227 --- /dev/null +++ b/benchmarks/write_concurrency_probe.py @@ -0,0 +1,30 @@ +"""Does the concurrency of WRITES change how fast the same data reads back? One client per thread, like the adapter.""" +import sys,time,zlib,threading,os,mmap +from concurrent.futures import ThreadPoolExecutor as P +from hypercache.client import HyperCacheClient +from hypercache.datapath import DirectBlockReader, DirectBlockWriter +SZ=14*1024*1024; N=256; sock=sys.argv[1]; WP=int(sys.argv[2]); tl=threading.local(); w=DirectBlockWriter(max_workers=8) +buf=mmap.mmap(-1,SZ); buf.write(os.urandom(SZ)); v=memoryview(buf); L=[None]*N +def cl(): + if not hasattr(tl,'c'): tl.c=HyperCacheClient(socket_path=sock) + return tl.c +def put(i): + c=cl(); u=f"hypercache://kv_cache/w/{i}.kv"; s=c.stage_write(u,SZ,tier="nvme",auto_flush_s3=False); w.write_chunks(s.chunk_layout,v) + p=0;cr=[] + for ch in s.chunk_layout: cr.append(zlib.crc32(v[p:p+ch.length])&0xffffffff); p+=ch.length + assert c.commit_write(u,local_only=True,chunk_checksums=cr); L[i]=c.locate(u,auto_ingest=False).chunk_layout +t=time.time() +with P(WP) as e: list(e.map(put,range(N))) +off=[l[0].offset for l in L]; seq=sum(1 for a,b in zip(off,off[1:]) if b-a==SZ+ (4194304-SZ%4194304 if SZ%4194304 else 0) or abs(b-a)<=16*1024*1024) +print(f"write_parallel={WP}: {N*SZ/1e6/(time.time()-t):.0f} MB/s",flush=True) +def rd(wk,o): + r=DirectBlockReader(max_workers=wk,verify_checksums=True); bufs=[memoryview(mmap.mmap(-1,SZ)) for _ in range(o)] + tb=threading.local(); idx=iter(range(o)); lk=threading.Lock() + def one(l): + if not hasattr(tb,'b'): + with lk: tb.b=bufs[next(idx)] + r.read_range_into(l,0,SZ,tb.b) + t=time.time() + with P(o) as e: list(e.map(one,L)) + d=time.time()-t; r.close(); print(f" read parallel={o:2} io_workers={wk:2}: {N*SZ/1e6/d:5.0f} MB/s",flush=True) +for o,wk in [(4,4),(8,8),(16,16),(4,4),(8,8),(16,16)]: rd(wk,o) diff --git a/client-py/hypercache/client.py b/client-py/hypercache/client.py index 4f656cd..752533a 100644 --- a/client-py/hypercache/client.py +++ b/client-py/hypercache/client.py @@ -54,6 +54,8 @@ class LocateResult: error_message: Optional[str] = None # Layout generation reported by the daemon (changes whenever the URI is re-ingested or rewritten) generation: Optional[int] = None + # Write status reported by daemons that support it, such as "STAGED" or "LOCAL_ONLY" + sync_status: Optional[str] = None @property def is_hit(self) -> bool: @@ -242,6 +244,7 @@ def locate( chunk_size=resp.get("chunk_size", 4194304), chunk_layout=chunk_layout, generation=resp.get("generation"), + sync_status=resp.get("sync_status"), ) elif status == "MISS": return LocateResult( @@ -426,10 +429,17 @@ def commit_write( uri: str, sha256: Optional[str] = None, write_through: bool = False, + local_only: bool = False, + chunk_checksums: Optional[List[int]] = None, ) -> bool: """ Commits a staged write in the control plane, triggering background sync to S3 (write-back) or synchronously waiting for authoritative backend flush (write-through). + + With local_only=True the object stays on this host: it is never flushed to a backend + and remains evictable. chunk_checksums records per-chunk CRC32 values for it, in layout + order. A daemon without local-only support ignores both and flushes the object, + so check get_write_status() for "LOCAL_ONLY" when that matters. """ req = { "action": "commit_write", @@ -438,6 +448,10 @@ def commit_write( } if sha256 is not None: req["sha256"] = sha256 + if local_only: + req["local_only"] = True + if chunk_checksums is not None: + req["chunk_checksums"] = chunk_checksums # Commit hashes the staged data (when sha256 is given) and, for write-through, uploads it resp = self._send_request(req, timeout=self.ingest_timeout) diff --git a/client-py/hypercache/datapath.py b/client-py/hypercache/datapath.py index c355204..3265dfe 100644 --- a/client-py/hypercache/datapath.py +++ b/client-py/hypercache/datapath.py @@ -7,9 +7,12 @@ from __future__ import annotations +import ctypes +import errno import logging import mmap import os +import stat import threading import zlib from concurrent.futures import ThreadPoolExecutor @@ -515,26 +518,109 @@ class DirectBlockWriter: """ Direct Block Writer for write-back and write-through caching. Writes byte slices to striped physical NVMe block devices or POSIX shared memory chunks. + + With direct_on_block_devices=True, writes to raw block devices use O_DIRECT. In testing on one + drive this raised both store speed and later read speed (benchmarks/results/lmcache_and_ttft.md). + Whatever O_DIRECT can't take goes through the page cache, so a write never fails because of it. + Callers must still commit, because the daemon's sync is what makes the data durable. """ - def __init__(self, max_workers: Optional[int] = None): + def __init__(self, max_workers: Optional[int] = None, direct_on_block_devices: bool = False): self._fd_cache: Dict[str, int] = {} + self._direct_fds: Dict[str, Optional[int]] = {} + self._direct_on_block_devices = direct_on_block_devices + self._fd_lock = threading.Lock() if max_workers is None: max_workers = min(64, max(16, (os.cpu_count() or 4) * 4)) self._max_workers = max_workers self._executor = ThreadPoolExecutor(max_workers=max_workers) def _get_write_fd(self, device_path: str) -> int: - if device_path not in self._fd_cache: - try: - fd = os.open(device_path, os.O_RDWR) - self._fd_cache[device_path] = fd - except OSError as e: - logger.error(f"Failed to open device {device_path} for write: {e}") + with self._fd_lock: + if device_path not in self._fd_cache: + try: + fd = os.open(device_path, os.O_RDWR) + self._fd_cache[device_path] = fd + except OSError as e: + logger.error(f"Failed to open device {device_path} for write: {e}") + raise + return self._fd_cache[device_path] + + @staticmethod + def _pwrite_all(fd: int, data: memoryview, offset: int) -> None: + # pwrite may write fewer bytes than asked, for example when the disk is nearly full + while len(data) > 0: + written = os.pwrite(fd, data, offset) + if written == 0: + raise IOError(f"Wrote 0 bytes at offset {offset}") + data = data[written:] + offset += written + + @staticmethod + def _is_block_device(device_path: str) -> bool: + try: + return stat.S_ISBLK(os.stat(device_path).st_mode) + except OSError: + return False + + @staticmethod + def _open_direct(device_path: str) -> int: + return os.open(device_path, os.O_RDWR | os.O_DIRECT) + + @staticmethod + def _is_aligned(data: memoryview, block_size: int) -> bool: + # The address of a read-only buffer isn't available here, so treat it as unaligned + if data.readonly: + return False + return ctypes.addressof(ctypes.c_char.from_buffer(data)) % block_size == 0 + + def _get_direct_fd(self, device_path: str) -> Optional[int]: + if not self._direct_on_block_devices: + return None + with self._fd_lock: + if device_path not in self._direct_fds: + fd = None + if hasattr(os, "O_DIRECT") and self._is_block_device(device_path): + try: + fd = self._open_direct(device_path) + except OSError as e: + logger.debug(f"O_DIRECT is unavailable on {device_path}: {e}") + self._direct_fds[device_path] = fd + return self._direct_fds[device_path] + + def _write_device_chunk(self, device_path: str, data: memoryview, offset: int) -> None: + direct_fd = self._get_direct_fd(device_path) + written = 0 + if direct_fd is not None: + written = self._write_whole_blocks_direct(direct_fd, device_path, data, offset) + if written < len(data): + self._pwrite_all(self._get_write_fd(device_path), data[written:], offset + written) + + def _write_whole_blocks_direct(self, fd: int, device_path: str, data: memoryview, offset: int) -> int: + """Writes as many whole blocks as O_DIRECT accepts. Returns the bytes written.""" + block_size = logical_block_size(device_path) + whole = len(data) - len(data) % block_size + if whole == 0 or offset % block_size != 0: + return 0 + source = data[:whole] + if not self._is_aligned(source, block_size): + # An mmap is page-aligned, and is freed along with the views of it + source = memoryview(mmap.mmap(-1, whole)) + source[:] = data[:whole] + written = 0 + try: + while written < whole: + count = os.pwrite(fd, source[written:], offset + written) + written += count + if count == 0 or count % block_size != 0: + break + except OSError as e: + if e.errno != errno.EINVAL: raise - return self._fd_cache[device_path] + logger.debug(f"O_DIRECT write refused on {device_path}: {e}") + return written - def _write_ram_chunk(self, target_path: str, chunk_data: bytes) -> None: + def _write_ram_chunk(self, target_path: str, chunk_data: Union[bytes, memoryview]) -> None: # The daemon creates staged RAM chunk files. Never create the directory here: if it is # missing, this process does not share /dev/shm with the daemon, and writing a private # copy would make the checkpoint silently disappear. @@ -557,7 +643,7 @@ def write_chunks( if not chunk_layout or not data: return 0 - view = memoryview(data) + view = memoryview(data).cast("B") total_len = len(view) current_virtual_offset = 0 tasks = [] @@ -571,14 +657,14 @@ def write_chunks( break slice_end = min(chunk_end, total_len) - slice_bytes = bytes(view[chunk_start:slice_end]) + # A view, not a copy: this method waits for every write before returning + slice_bytes = view[chunk_start:slice_end] if chunk.tier == "ram": tasks.append(self._executor.submit(self._write_ram_chunk, chunk.device, slice_bytes)) else: - fd = self._get_write_fd(chunk.device) tasks.append( - self._executor.submit(os.pwrite, fd, slice_bytes, chunk.offset) + self._executor.submit(self._write_device_chunk, chunk.device, slice_bytes, chunk.offset) ) # Wait for all chunks to write @@ -595,5 +681,12 @@ def close(self) -> None: except Exception: pass self._fd_cache.clear() + for fd in self._direct_fds.values(): + if fd is not None: + try: + os.close(fd) + except Exception: + pass + self._direct_fds.clear() self._executor.shutdown(wait=False) diff --git a/client-py/hypercache/integrations/lmcache_l2.py b/client-py/hypercache/integrations/lmcache_l2.py new file mode 100644 index 0000000..0138aa2 --- /dev/null +++ b/client-py/hypercache/integrations/lmcache_l2.py @@ -0,0 +1,427 @@ +""" +LMCache L2 adapter backed by the HyperCache daemon. + +Lets an LMCache MP-mode server keep KV-cache chunks on HyperCache's RAM and NVMe tiers. +LMCache loads it as a plugin, so `hypercache` must be importable by the LMCache server: + + { + "type": "plugin", + "module_path": "hypercache.integrations.lmcache_l2", + "class_name": "HyperCacheL2Adapter", + "adapter_params": { + "namespace": "qwen2.5-7b-awq-rev1234", + "socket_path": "/run/hypercache/hypercache.sock", + "tier": "nvme" + } + } + +Behaviour worth knowing: + +- Blocks are LOCAL_ONLY. They are never flushed to a backend and stay evictable, because + KV data derives from user prompts and can be recomputed. +- `namespace` is required. LMCache's key has a model name but no revision, dtype or engine + settings, so changing weights under the same name would otherwise return wrong KV data. + Set it to something that changes when any of those change. +- Any doubt about a block is a miss. Lookup only accepts committed blocks with a checksum + for every chunk, and load verifies every chunk before reporting success. +- Capacity belongs to the daemon, which evicts under pressure. LMCache's global eviction is + off, so `list_l2_keys` and IsolatedLRU quotas are not supported. The daemon can evict a + block after lookup succeeded; that load then reports a miss for the key. + +Requires LMCache 0.5.5 or 0.5.6, and a daemon with local-only commit support. Against an +older daemon, stores fail before any data is written and lookups miss. + +Only this module imports LMCache. `hypercache.integrations` must not import it. +""" + +from __future__ import annotations + +import itertools +import logging +import threading +import zlib +from concurrent.futures import ThreadPoolExecutor +from typing import Any, Callable, Dict, List, Optional +from urllib.parse import quote + +import torch # noqa: F401 # must precede lmcache_native +from lmcache.lmcache_native import Bitmap +from lmcache.v1.distributed.internal_api import L2StoreResult +from lmcache.v1.distributed.l2_adapters.base import L2AdapterInterface, L2TaskId +from lmcache.v1.distributed.l2_adapters.config import L2AdapterConfigBase +from lmcache.v1.platform import create_event_notifier + +from hypercache.client import HyperCacheClient, LocateResult +from hypercache.datapath import ChecksumMismatchError, DirectBlockReader, DirectBlockWriter + +logger = logging.getLogger(__name__) + +_LOCAL_ONLY = "LOCAL_ONLY" + + +class HyperCacheL2AdapterConfig(L2AdapterConfigBase): + """Config for HyperCacheL2Adapter.""" + + def __init__( + self, + namespace: str, + socket_path: Optional[str] = None, + tier: str = "nvme", + num_workers: int = 4, + timeout_s: float = 30.0, + ): + if not namespace: + raise ValueError("namespace is required: use a value that changes when the model weights or dtype change") + if num_workers < 1: + raise ValueError("num_workers must be at least 1") + self.namespace = namespace + self.socket_path = socket_path + self.tier = tier + self.num_workers = num_workers + self.timeout_s = timeout_s + + @classmethod + def from_dict(cls, d: dict) -> "HyperCacheL2AdapterConfig": + return cls( + namespace=d.get("namespace", ""), + socket_path=d.get("socket_path"), + tier=d.get("tier", "nvme"), + num_workers=int(d.get("num_workers", 4)), + timeout_s=float(d.get("timeout_s", 30.0)), + ) + + @classmethod + def help(cls) -> str: + return ( + "HyperCacheL2Adapter config fields:\n" + "- namespace (str, required): model fingerprint; change it when weights or dtype change\n" + "- socket_path (str): daemon socket (default: the client's default path)\n" + "- tier (str): 'nvme' or 'ram' (default 'nvme')\n" + "- num_workers (int): parallel chunk reads and writes per direction (default 4)\n" + "- timeout_s (float): daemon request timeout in seconds (default 30)\n" + ) + + +class HyperCacheL2Adapter(L2AdapterInterface): + """Stores LMCache objects in HyperCache. Called from two LMCache controller threads.""" + + def __init__(self, config: Any, **_kwargs: object): + if isinstance(config, dict): + config = HyperCacheL2AdapterConfig.from_dict(config) + super().__init__(0) # 0 turns off LMCache's global eviction: the daemon owns capacity + self._config = config + self._namespace = quote(config.namespace, safe="") + + self._store_efd = create_event_notifier() + self._lookup_efd = create_event_notifier() + self._load_efd = create_event_notifier() + + self._lock = threading.Lock() + self._task_ids = itertools.count() + self._done_store: Dict[L2TaskId, L2StoreResult] = {} + self._done_lookup: Dict[L2TaskId, Bitmap] = {} + self._done_load: Dict[L2TaskId, Bitmap] = {} + self._locks: Dict[str, int] = {} + self._storing: set = set() + self._daemon_supports_local_only = False + self._closed = False + self._counters = {"checksum_failures": 0, "load_failures": 0, "store_failures": 0} + + self._clients = threading.local() + self._all_clients: List[HyperCacheClient] = [] + self._reader = DirectBlockReader(max_workers=config.num_workers, verify_checksums=True) + self._writer = DirectBlockWriter(max_workers=config.num_workers, direct_on_block_devices=True) + + # Tasks and their per-key work use separate pools, so a task waiting on its keys can't + # occupy the thread they need. Each direction has its own, so slow commits can't delay reads. + self._lookup_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-lookup") + self._store_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-store") + self._load_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-load") + self._store_keys = ThreadPoolExecutor(config.num_workers, thread_name_prefix="hc-l2-store-key") + self._load_keys = ThreadPoolExecutor(config.num_workers, thread_name_prefix="hc-l2-load-key") + + # Event fds + + def get_store_event_fd(self) -> int: + return self._store_efd.fileno() + + def get_lookup_and_lock_event_fd(self) -> int: + return self._lookup_efd.fileno() + + def get_load_event_fd(self) -> int: + return self._load_efd.fileno() + + # Store + + def submit_store_task(self, keys: list, objects: list) -> L2TaskId: + task_id = next(self._task_ids) + self._store_tasks.submit(self._run_store, list(keys), list(objects), task_id) + return task_id + + def pop_completed_store_tasks(self) -> Dict[L2TaskId, L2StoreResult]: + with self._lock: + done = self._done_store + self._done_store = {} + return done + + def _run_store(self, keys: list, objects: list, task_id: L2TaskId) -> None: + stored_keys, stored_sizes = [], [] + success = True + try: + futures = [self._store_keys.submit(self._store_one, k, o) for k, o in zip(keys, objects)] + for key, future in zip(keys, futures): + try: + size = future.result() + except Exception as e: + logger.warning("Store failed for %s: %s", self._uri(key), e) + self._count("store_failures") + success = False + continue + if size > 0: + stored_keys.append(key) + stored_sizes.append(size) + if stored_keys: + self._notify_keys_stored(stored_keys, stored_sizes) + except Exception: + logger.exception("Store task %s failed", task_id) + success = False + with self._lock: + self._done_store[task_id] = L2StoreResult(success, sum(stored_sizes)) + self._store_efd.notify() + + def _store_one(self, key: Any, obj: Any) -> int: + """Returns the bytes stored, or 0 if the object is already stored or being stored.""" + uri = self._uri(key) + with self._lock: + if uri in self._storing: + return 0 + self._storing.add(uri) + try: + client = self._client() + if self._is_valid(client.locate(uri, auto_ingest=False)): + return 0 + + view = memoryview(obj.byte_array).cast("B") + staged = client.stage_write(uri, len(view), tier=self._config.tier, auto_flush_s3=False) + if not staged.is_staged: + raise IOError(f"stage_write failed: {staged.error_message}") + try: + self._require_local_only_support(client, uri) + self._writer.write_chunks(staged.chunk_layout, view) + checksums = self._chunk_checksums(staged.chunk_layout, view) + if not client.commit_write(uri, local_only=True, chunk_checksums=checksums): + raise IOError("commit_write failed") + except Exception: + self._evict_quietly(client, uri) + raise + return len(view) + finally: + with self._lock: + self._storing.discard(uri) + + def _require_local_only_support(self, client: HyperCacheClient, uri: str) -> None: + # An older daemon ignores local_only and would upload the block to its backend, so this + # has to be settled before the first commit. Only newer daemons report status on locate. + if self._daemon_supports_local_only: + return + if client.locate(uri, auto_ingest=False).sync_status != "STAGED": + raise IOError("the HyperCache daemon has no local-only commit support; upgrade it") + self._daemon_supports_local_only = True + + @staticmethod + def _chunk_checksums(layout: list, view: memoryview) -> List[int]: + checksums = [] + position = 0 + for chunk in layout: + checksums.append(zlib.crc32(view[position : position + chunk.length]) & 0xFFFFFFFF) + position += chunk.length + return checksums + + # Lookup and lock + + def submit_lookup_and_lock_task(self, keys: list, group_layout_descs: dict) -> L2TaskId: + task_id = next(self._task_ids) + self._lookup_tasks.submit(self._run_lookup, list(keys), task_id) + return task_id + + def query_lookup_and_lock_result(self, task_id: L2TaskId) -> Optional[Bitmap]: + with self._lock: + return self._done_lookup.pop(task_id, None) + + def submit_unlock(self, keys: list) -> None: + with self._lock: + for key in keys: + uri = self._uri(key) + count = self._locks.get(uri, 0) + if count <= 1: + self._locks.pop(uri, None) + else: + self._locks[uri] = count - 1 + + def _run_lookup(self, keys: list, task_id: L2TaskId) -> None: + bitmap = Bitmap(len(keys)) + try: + client = self._client() + for i, key in enumerate(keys): + uri = self._uri(key) + if self._is_valid(client.locate(uri, auto_ingest=False)): + with self._lock: + self._locks[uri] = self._locks.get(uri, 0) + 1 + bitmap.set(i) + except Exception as e: + # Keys already locked stay reported as hits; the rest are misses + logger.warning("Lookup failed: %s", e) + with self._lock: + self._done_lookup[task_id] = bitmap + self._lookup_efd.notify() + + @staticmethod + def _is_valid(location: LocateResult) -> bool: + return ( + location.is_hit + and location.sync_status == _LOCAL_ONLY + and bool(location.chunk_layout) + and all(chunk.checksum is not None for chunk in location.chunk_layout) + ) + + # Load + + def submit_load_task(self, keys: list, objects: list) -> L2TaskId: + task_id = next(self._task_ids) + self._load_tasks.submit(self._run_load, list(keys), list(objects), task_id) + return task_id + + def query_load_result(self, task_id: L2TaskId) -> Optional[Bitmap]: + with self._lock: + return self._done_load.pop(task_id, None) + + def _run_load(self, keys: list, objects: list, task_id: L2TaskId) -> None: + bitmap = Bitmap(len(keys)) + loaded = [] + try: + futures = [self._load_keys.submit(self._load_one, k, o) for k, o in zip(keys, objects)] + for i, (key, future) in enumerate(zip(keys, futures)): + if future.result(): + bitmap.set(i) + loaded.append(key) + if loaded: + self._notify_keys_accessed(loaded) + except Exception: + logger.exception("Load task %s failed", task_id) + with self._lock: + self._done_load[task_id] = bitmap + self._load_efd.notify() + + def _load_one(self, key: Any, obj: Any) -> bool: + uri = self._uri(key) + client = None + location = None + try: + client = self._client() + location = client.locate(uri, auto_ingest=False) + if not self._is_valid(location): + return False + view = memoryview(obj.byte_array).cast("B") + if location.object_size != len(view): + logger.warning("Size mismatch for %s: stored %d, buffer %d", uri, location.object_size, len(view)) + return False + return self._reader.read_range_into(location.chunk_layout, 0, len(view), view) == len(view) + except ChecksumMismatchError as e: + logger.error("Treating %s as a miss: %s", uri, e) + self._count("checksum_failures") + self._evict_if_unchanged(client, uri, location) + return False + except Exception as e: + logger.warning("Load failed for %s: %s", uri, e) + self._count("load_failures") + return False + + def _evict_if_unchanged(self, client: HyperCacheClient, uri: str, seen: LocateResult) -> None: + # A changed generation means the block was replaced during the read, so it isn't corrupt + try: + if client.locate(uri, auto_ingest=False).generation == seen.generation: + client.evict(uri) + except Exception as e: + logger.warning("Could not evict %s: %s", uri, e) + + # Delete, status, shutdown + + def delete(self, keys: list) -> None: + deleted_keys, deleted_sizes = [], [] + client = self._client() + for key in keys: + uri = self._uri(key) + with self._lock: + if self._locks.get(uri, 0) > 0: + continue + try: + location = client.locate(uri, auto_ingest=False) + if location.is_hit and client.evict(uri): + deleted_keys.append(key) + deleted_sizes.append(location.object_size) + except Exception as e: + logger.warning("Delete failed for %s: %s", uri, e) + if deleted_keys: + self._notify_keys_deleted(deleted_keys, deleted_sizes) + + def report_status(self) -> dict: + status: Dict[str, Any] = {"is_healthy": True, "namespace": self._config.namespace} + try: + self._client().get_status() + except Exception as e: + status.update(is_healthy=False, error=str(e)) + with self._lock: + status.update(self._counters) + status["locked_keys"] = len(self._locks) + return status + + def close(self) -> None: + with self._lock: + if self._closed: + return + self._closed = True + # Tasks first, because they wait on the per-key pools + for pool in (self._lookup_tasks, self._store_tasks, self._load_tasks, self._store_keys, self._load_keys): + pool.shutdown(wait=True) + self._reader.close() + self._writer.close() + with self._lock: + clients, self._all_clients = self._all_clients, [] + for client in clients: + client.close() + self._store_efd.close() + self._lookup_efd.close() + self._load_efd.close() + + # Helpers + + def _uri(self, key: Any) -> str: + # Every field is quoted so none can add a path level. Empty and non-empty salts have + # different shapes, so no salt can collide with "no salt". + salt = f"s-{quote(key.cache_salt, safe='')}" if key.cache_salt else "_" + model = quote(key.model_name, safe="") + return ( + f"hypercache://kv_cache/{self._namespace}/{model}/{key.kv_rank:x}/" + f"{key.object_group_id:x}/{salt}/{key.chunk_hash.hex()}.kv" + ) + + def _client(self) -> HyperCacheClient: + # One per thread: a client serializes its requests, so a slow commit would block lookups + client = getattr(self._clients, "client", None) + if client is None: + client = HyperCacheClient(socket_path=self._config.socket_path, timeout=self._config.timeout_s) + self._clients.client = client + with self._lock: + self._all_clients.append(client) + return client + + def _count(self, name: str) -> None: + with self._lock: + self._counters[name] += 1 + + @staticmethod + def _evict_quietly(client: HyperCacheClient, uri: str) -> None: + try: + client.evict(uri) + except Exception as e: + logger.warning("Could not clean up %s: %s", uri, e) diff --git a/client-py/hypercache/kv_store.py b/client-py/hypercache/kv_store.py index c0a988e..3714480 100644 --- a/client-py/hypercache/kv_store.py +++ b/client-py/hypercache/kv_store.py @@ -2,9 +2,13 @@ HyperCache KV-Cache Prefix Block Store (`HyperCacheKVStore`). Provides a content-addressed key-value block interface over HyperCache's Tier-1 -Host RAM (`/dev/shm` / HugePages) and Tier-2 Striped NVMe engine, enabling -plug-and-play KV-cache offloading for LMCache, vLLM prefix caching, and -NVIDIA Dynamo KVBM. +Host RAM (`/dev/shm` / HugePages) and Tier-2 Striped NVMe engine. + +This is a building block for code that manages its own KV-cache blocks. For LMCache, +use `hypercache.integrations.lmcache_l2`. There is no NVIDIA Dynamo KVBM integration. + +Blocks stay on this host and remain evictable, unless write_through=True asks for a +synchronous backend flush. """ from __future__ import annotations @@ -103,7 +107,11 @@ def put_kv_block( return False self._writer.write_chunks(stage_res.chunk_layout, raw_bytes) - return self._client.commit_write(uri, write_through=self.write_through) + return self._client.commit_write( + uri, + write_through=self.write_through, + local_only=not self.write_through, + ) def get_kv_block( self, @@ -117,7 +125,7 @@ def get_kv_block( """ uri = self._make_uri(block_key) loc = self._client.locate(uri, auto_ingest=False) - if not loc.is_hit: + if not self._is_readable(loc): return None if out_tensor is not None: @@ -143,7 +151,12 @@ def get_kv_block( def exists_kv_block(self, block_key: str) -> bool: uri = self._make_uri(block_key) - return self._client.locate(uri, auto_ingest=False).is_hit + return self._is_readable(self._client.locate(uri, auto_ingest=False)) + + @staticmethod + def _is_readable(loc: Any) -> bool: + # A staged layout is published before its data is written, so it isn't readable yet + return loc.is_hit and loc.sync_status != "STAGED" def close(self) -> None: self._reader.close() diff --git a/client-py/hypercache/pipeline.py b/client-py/hypercache/pipeline.py index 68aa670..8d6870d 100644 --- a/client-py/hypercache/pipeline.py +++ b/client-py/hypercache/pipeline.py @@ -1,10 +1,12 @@ """ -HyperCache Layer-by-Layer Pipelined Loader & Compute-I/O Overlap Engine. +HyperCache layer-by-layer pipelined loader. -Enables sub-100ms perceived cold starts for LLM inference by: -1. Immediately loading the Embedding & Layer 0 into GPU VRAM / Host RAM. -2. Beginning model forward pass execution without waiting for the full 70B model. -3. Concurrently prefetching Layer i+1 in a background worker while the GPU executes Layer i. +Reads a model's byte ranges in order and prefetches the next ranges in the background. An +engine that can run layers as their weights arrive can use this to overlap compute with I/O. + +This module only returns bytes. It does not know true layer boundaries unless the caller sets +`layers`, and it does not run the model. The first token needs every layer, so overlap saves at +most min(T_io, T_compute). See benchmarks/results/lmcache_and_ttft.md. """ from __future__ import annotations @@ -34,7 +36,7 @@ class LayerDescriptor: class HyperCachePipelinedLoader: """ - Pipelined, compute-overlapped model loader for streaming transformer weights. + Pipelined reader for streaming transformer weights in order. """ def __init__( @@ -102,7 +104,8 @@ def _read_layer_bytes(self, layer: LayerDescriptor) -> bytes: def load_initial_layer(self) -> Tuple[LayerDescriptor, bytes]: """ Synchronously loads Layer 0 / Embedding and triggers background prefetching for Layer 1. - Unblocks the inference engine in ~20-50 ms. + This takes as long as the first range takes to read: 880 ms for a 1 GB embedding table in + benchmarks/results/lmcache_and_ttft.md. """ if not self.layers: raise ValueError("No layers found in model.") diff --git a/client-py/pyproject.toml b/client-py/pyproject.toml index 250d7af..7129672 100644 --- a/client-py/pyproject.toml +++ b/client-py/pyproject.toml @@ -40,6 +40,9 @@ Repository = "https://github.com/looelabs/hypercache" Issues = "https://github.com/looelabs/hypercache/issues" [project.optional-dependencies] +lmcache = [ + "lmcache>=0.5.5,<0.6; python_version >= '3.10'", +] gpu = [ "kvikio-cu12>=24.0.0", "cupy-cuda12x>=12.0.0", diff --git a/client-py/tests/test_direct_writer.py b/client-py/tests/test_direct_writer.py new file mode 100644 index 0000000..31ca86c --- /dev/null +++ b/client-py/tests/test_direct_writer.py @@ -0,0 +1,229 @@ +""" +Unit tests for DirectBlockWriter's O_DIRECT mode. They run anywhere, including macOS, by replacing +the direct file descriptor with a plain one and recording what each write was given. The last test +uses real O_DIRECT where the platform and filesystem support it. +""" + +import ctypes +import errno +import mmap +import os +import shutil +import tempfile +import unittest +from unittest import mock + +from hypercache.datapath import ChunkLocation, DirectBlockWriter + +BLOCK = 4096 + + +def pattern(size, seed=7): + return bytes((i * seed + i // 251) % 256 for i in range(size)) + + +def aligned_buffer(data, shift=0): + view = memoryview(mmap.mmap(-1, len(data) + shift + BLOCK))[shift : shift + len(data)] + view[:] = data + return view + + +class WriterTestCase(unittest.TestCase): + def setUp(self): + handle, self.path = tempfile.mkstemp() + os.ftruncate(handle, 64 * 1024 * 1024) + os.close(handle) + self.addCleanup(os.unlink, self.path) + self.direct_fds = [] + self.direct_writes = [] + self.real_pwrite = os.pwrite + + def open_direct(path): + fd = os.open(path, os.O_RDWR) + self.direct_fds.append(fd) + return fd + + for target, replacement in ( + ("hypercache.datapath.DirectBlockWriter._is_block_device", staticmethod(lambda path: True)), + ("hypercache.datapath.DirectBlockWriter._open_direct", staticmethod(open_direct)), + ("hypercache.datapath.logical_block_size", lambda path: BLOCK), + ("hypercache.datapath.os.pwrite", self.spy_pwrite), + ): + patcher = mock.patch(target, replacement) + patcher.start() + self.addCleanup(patcher.stop) + if not hasattr(os, "O_DIRECT"): + patcher = mock.patch("hypercache.datapath.os.O_DIRECT", 0, create=True) + patcher.start() + self.addCleanup(patcher.stop) + self.writer = DirectBlockWriter(max_workers=4, direct_on_block_devices=True) + self.addCleanup(self.writer.close) + + def spy_pwrite(self, fd, data, offset): + if fd in self.direct_fds: + address = ctypes.addressof(ctypes.c_char.from_buffer(data)) + self.direct_writes.append((address % BLOCK, len(data), offset)) + return self.real_pwrite(fd, data, offset) + + def layout(self, *lengths, start=BLOCK): + chunks, offset = [], start + for length in lengths: + chunks.append(ChunkLocation(device=self.path, offset=offset, length=length)) + offset += (length + BLOCK - 1) // BLOCK * BLOCK + return chunks + + def on_disk(self, offset, length): + with open(self.path, "rb") as f: + f.seek(offset) + return f.read(length) + + def assert_direct_writes_are_aligned(self): + self.assertTrue(self.direct_writes, "expected O_DIRECT to be used") + for address_remainder, length, offset in self.direct_writes: + self.assertEqual(address_remainder, 0) + self.assertEqual(length % BLOCK, 0) + self.assertEqual(offset % BLOCK, 0) + + def test_aligned_buffer_goes_direct_across_chunks(self): + data = pattern(3 * 1024 * 1024) + self.writer.write_chunks(self.layout(1024 * 1024, 1024 * 1024, 1024 * 1024), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assert_direct_writes_are_aligned() + self.assertEqual(sum(w[1] for w in self.direct_writes), len(data)) + + def test_unaligned_buffer_is_copied_to_an_aligned_one(self): + data = pattern(256 * 1024) + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data, shift=1)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assert_direct_writes_are_aligned() + + def test_read_only_bytes_are_supported(self): + data = pattern(64 * 1024) + self.writer.write_chunks(self.layout(len(data)), data) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assert_direct_writes_are_aligned() + + def test_partial_last_block_does_not_touch_its_neighbour(self): + neighbour_offset = BLOCK + 3 * BLOCK + with open(self.path, "r+b") as f: + f.seek(BLOCK + 2 * BLOCK + 100) + f.write(b"\xAB" * (neighbour_offset - (BLOCK + 2 * BLOCK + 100) + BLOCK)) + data = pattern(2 * BLOCK + 100) + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assertEqual(self.on_disk(BLOCK + len(data), 8), b"\xAB" * 8) + self.assertEqual(self.on_disk(neighbour_offset, BLOCK), b"\xAB" * BLOCK) + self.assertEqual(sum(w[1] for w in self.direct_writes), 2 * BLOCK) + self.assert_direct_writes_are_aligned() + + def test_less_than_a_block_never_goes_direct(self): + data = pattern(100) + self.writer.write_chunks(self.layout(100), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, 100), data) + self.assertEqual(self.direct_writes, []) + + def test_unaligned_offset_never_goes_direct(self): + data = pattern(2 * BLOCK) + self.writer.write_chunks(self.layout(len(data), start=BLOCK + 512), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK + 512, len(data)), data) + self.assertEqual(self.direct_writes, []) + + def test_refused_direct_write_falls_back_to_the_page_cache(self): + data = pattern(16 * BLOCK) + + def refuse(fd, buffer, offset): + if fd in self.direct_fds: + raise OSError(errno.EINVAL, "refused") + return self.real_pwrite(fd, buffer, offset) + + with mock.patch("hypercache.datapath.os.pwrite", refuse): + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + + def test_short_direct_writes_complete_the_chunk(self): + for short in (BLOCK, BLOCK + 17): + with self.subTest(short=short): + data = pattern(16 * BLOCK, seed=short % 13 + 1) + calls = [] + + def one_short_write(fd, buffer, offset, short=short, calls=calls): + if fd in self.direct_fds and not calls: + calls.append(1) + return self.real_pwrite(fd, buffer[:short], offset) + return self.real_pwrite(fd, buffer, offset) + + with mock.patch("hypercache.datapath.os.pwrite", one_short_write): + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + + def test_real_errors_are_reported(self): + def full(fd, buffer, offset): + raise OSError(errno.ENOSPC, "no space") + + with mock.patch("hypercache.datapath.os.pwrite", full): + with self.assertRaises(OSError) as caught: + self.writer.write_chunks(self.layout(4 * BLOCK), aligned_buffer(pattern(4 * BLOCK))) + self.assertEqual(caught.exception.errno, errno.ENOSPC) + + def test_a_write_that_makes_no_progress_is_an_error(self): + with mock.patch("hypercache.datapath.os.pwrite", lambda fd, buffer, offset: 0): + with self.assertRaises(IOError): + self.writer.write_chunks(self.layout(4 * BLOCK), aligned_buffer(pattern(4 * BLOCK))) + + def test_off_by_default(self): + writer = DirectBlockWriter(max_workers=2) + self.addCleanup(writer.close) + data = pattern(4 * BLOCK) + writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assertEqual(self.direct_writes, []) + + def test_regular_files_are_not_direct(self): + with mock.patch("hypercache.datapath.DirectBlockWriter._is_block_device", staticmethod(lambda path: False)): + data = pattern(4 * BLOCK) + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + self.assertEqual(self.direct_writes, []) + + def test_failure_to_open_direct_uses_the_page_cache(self): + def cannot_open(path): + raise OSError(errno.EINVAL, "no O_DIRECT here") + + with mock.patch("hypercache.datapath.DirectBlockWriter._open_direct", staticmethod(cannot_open)): + data = pattern(4 * BLOCK) + self.writer.write_chunks(self.layout(len(data)), aligned_buffer(data)) + self.assertEqual(self.on_disk(BLOCK, len(data)), data) + + def test_ram_chunks_never_go_direct(self): + target = self.path + ".ram" + self.addCleanup(lambda: os.path.exists(target) and os.unlink(target)) + data = pattern(4 * BLOCK) + chunk = ChunkLocation(device=target, offset=0, length=len(data), tier="ram") + self.writer.write_chunks([chunk], aligned_buffer(data)) + with open(target, "rb") as f: + self.assertEqual(f.read(), data) + self.assertEqual(self.direct_writes, []) + + +class RealDirectIOTest(unittest.TestCase): + @unittest.skipUnless(hasattr(os, "O_DIRECT"), "needs O_DIRECT") + def test_real_o_direct_or_fallback_writes_correct_bytes(self): + # Not every filesystem allows O_DIRECT. Either way, the bytes must be right. + directory = tempfile.mkdtemp(dir=os.getcwd()) + self.addCleanup(shutil.rmtree, directory, ignore_errors=True) + path = os.path.join(directory, "device") + with open(path, "wb") as f: + f.truncate(8 * 1024 * 1024) + data = pattern(2 * 1024 * 1024 + 300) + layout = [ChunkLocation(device=path, offset=4096, length=len(data))] + with mock.patch("hypercache.datapath.DirectBlockWriter._is_block_device", staticmethod(lambda p: True)): + writer = DirectBlockWriter(max_workers=2, direct_on_block_devices=True) + writer.write_chunks(layout, aligned_buffer(data)) + writer.close() + with open(path, "rb") as f: + f.seek(4096) + self.assertEqual(f.read(len(data)), data) + + +if __name__ == "__main__": + unittest.main() diff --git a/client-py/tests/test_lmcache_adapter.py b/client-py/tests/test_lmcache_adapter.py new file mode 100644 index 0000000..fd4e230 --- /dev/null +++ b/client-py/tests/test_lmcache_adapter.py @@ -0,0 +1,484 @@ +""" +Unit tests for the LMCache L2 adapter, using a fake daemon on a real socket and a real data file. + +LMCache only ships Linux wheels, so its modules are stubbed where it isn't installed. +scripts/e2e/lmcache_l2_e2e.py covers the real LMCache and the real daemon. +""" + +import importlib.util +import json +import os +import select +import shutil +import socket +import sys +import tempfile +import threading +import time +import types +import unittest +from dataclasses import dataclass + + +def _install_lmcache_stubs(): + class Bitmap: + def __init__(self, size): + self.bits = [False] * size + + def set(self, index): + self.bits[index] = True + + def test(self, index): + return self.bits[index] + + class L2StoreResult(int): + def __new__(cls, success, bytes_transferred=0): + return super().__new__(cls, bytes_transferred if success else -1) + + class L2AdapterInterface: + def __init__(self, max_capacity_bytes=0): + self.events = {"stored": [], "accessed": [], "deleted": []} + + def _notify_keys_stored(self, keys, sizes): + self.events["stored"].extend(keys) + + def _notify_keys_accessed(self, keys): + self.events["accessed"].extend(keys) + + def _notify_keys_deleted(self, keys, sizes): + self.events["deleted"].extend(keys) + + class Notifier: + def __init__(self): + self.read_fd, self.write_fd = os.pipe() + + def fileno(self): + return self.read_fd + + def notify(self): + os.write(self.write_fd, b"x") + + def close(self): + os.close(self.read_fd) + os.close(self.write_fd) + + modules = { + "lmcache": {}, + "lmcache.lmcache_native": {"Bitmap": Bitmap}, + "lmcache.v1": {}, + "lmcache.v1.platform": {"create_event_notifier": Notifier}, + "lmcache.v1.distributed": {}, + "lmcache.v1.distributed.internal_api": {"L2StoreResult": L2StoreResult}, + "lmcache.v1.distributed.l2_adapters": {}, + "lmcache.v1.distributed.l2_adapters.base": {"L2AdapterInterface": L2AdapterInterface, "L2TaskId": int}, + "lmcache.v1.distributed.l2_adapters.config": {"L2AdapterConfigBase": object}, + } + for name, attributes in modules.items(): + module = types.ModuleType(name) + module.__dict__.update(attributes) + sys.modules[name] = module + + +try: + import lmcache.v1.distributed.l2_adapters.base # noqa: F401 + + HAVE_LMCACHE = True +except ImportError: + HAVE_LMCACHE = False + _install_lmcache_stubs() + +# The adapter imports torch only to set LMCache's import order. Where torch is absent, stub it for +# this one import so that other test modules still see that it's missing. +_torch_missing = "torch" not in sys.modules and importlib.util.find_spec("torch") is None +if _torch_missing: + sys.modules["torch"] = types.ModuleType("torch") +from hypercache.integrations.lmcache_l2 import HyperCacheL2Adapter, HyperCacheL2AdapterConfig # noqa: E402 + +if _torch_missing: + del sys.modules["torch"] + +CHUNK_SIZE = 4 * 1024 * 1024 + + +@dataclass(frozen=True) +class Key: + chunk_hash: bytes + model_name: str = "org/model" + kv_rank: int = 0 + object_group_id: int = 0 + cache_salt: str = "" + + +class Obj: + def __init__(self, data): + self.byte_array = memoryview(bytearray(data)) + + +def payload(size, seed=1): + return bytes((i * seed) % 251 for i in range(4096)) * (size // 4096) + bytes(size % 4096) + + +class FakeDaemon: + """Speaks enough of the daemon protocol, with the same chunking and commit rules.""" + + def __init__(self, directory, reports_sync_status=True): + self.arena = os.path.join(directory, "arena.raw") + with open(self.arena, "wb") as f: + f.truncate(256 * 1024 * 1024) + self.socket_path = os.path.join(directory, "d.sock") + self.reports_sync_status = reports_sync_status + self.objects = {} + self.requests = [] + self.next_offset = 0 + self.generation = 0 + self.lock = threading.Lock() + self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self.server.bind(self.socket_path) + self.server.listen(32) + threading.Thread(target=self._accept, daemon=True).start() + + def stop(self): + self.server.close() + os.unlink(self.socket_path) + + def _accept(self): + while True: + try: + conn, _ = self.server.accept() + except OSError: + return + threading.Thread(target=self._serve, args=(conn,), daemon=True).start() + + def _serve(self, conn): + with conn, conn.makefile("rb") as lines: + for line in lines: + request = json.loads(line) + with self.lock: + self.requests.append(request) + response = self._handle(request) + conn.sendall((json.dumps(response) + "\n").encode()) + + def _handle(self, r): + action, uri = r.get("action"), r.get("uri") + if action == "stage_write": + layout, left = [], r["size_bytes"] + while left > 0: + length = min(left, CHUNK_SIZE) + layout.append({"device": self.arena, "offset": self.next_offset, "length": length, "tier": "nvme"}) + self.next_offset += CHUNK_SIZE + left -= length + self.generation += 1 + self.objects[uri] = { + "size": r["size_bytes"], + "layout": layout, + "status": "STAGED", + "generation": self.generation, + } + return { + "status": "WRITESTAGED", + "object_size": r["size_bytes"], + "chunk_size": CHUNK_SIZE, + "chunk_layout": layout, + "sync_status": "STAGED", + } + if action == "commit_write": + entry = self.objects.get(uri) + if entry is None: + return {"status": "ERROR", "error_message": "not staged"} + crcs = r.get("chunk_checksums") + if crcs is not None: + if len(crcs) != len(entry["layout"]): + return {"status": "ERROR", "error_message": "bad checksum count"} + for chunk, crc in zip(entry["layout"], crcs): + chunk["checksum"] = crc + entry["status"] = "LOCAL_ONLY" if r.get("local_only") else "COMMITTED" + return {"status": "WRITECOMMITTED", "object_size": entry["size"]} + if action in ("locate", "ingest"): + entry = self.objects.get(uri) + if entry is None: + return {"status": "MISS"} + response = { + "status": "HIT", + "object_size": entry["size"], + "chunk_size": CHUNK_SIZE, + "chunk_layout": entry["layout"], + "generation": entry["generation"], + } + if self.reports_sync_status: + response["sync_status"] = entry["status"] + return response + if action == "evict": + self.objects.pop(uri, None) + return {"status": "EVICTED"} + return {"status": "PONG"} + + def actions(self, name): + with self.lock: + return [r for r in self.requests if r.get("action") == name] + + def corrupt(self, uri, chunk_index=0): + chunk = self.objects[uri]["layout"][chunk_index] + with open(self.arena, "r+b") as f: + f.seek(chunk["offset"] + 17) + byte = f.read(1) + f.seek(chunk["offset"] + 17) + f.write(bytes([byte[0] ^ 0xFF])) + + +class AdapterTestCase(unittest.TestCase): + def setUp(self): + # Short path: AF_UNIX paths have a low length limit on macOS + self.directory = tempfile.mkdtemp(prefix="hcl2", dir="/tmp") + self.daemon = FakeDaemon(self.directory) + self.adapter = self.make_adapter() + self.addCleanup(shutil.rmtree, self.directory, ignore_errors=True) + self.addCleanup(self.adapter.close) + + def make_adapter(self, namespace="ns1"): + return HyperCacheL2Adapter( + HyperCacheL2AdapterConfig(namespace=namespace, socket_path=self.daemon.socket_path, timeout_s=2) + ) + + def store(self, adapter, keys, objects): + task_id = adapter.submit_store_task(keys, objects) + deadline = time.time() + 10 + while time.time() < deadline: + select.select([adapter.get_store_event_fd()], [], [], 0.05) + done = adapter.pop_completed_store_tasks() + if task_id in done: + return done[task_id] + self.fail("store task did not finish") + + def lookup(self, adapter, keys): + task_id = adapter.submit_lookup_and_lock_task(keys, {}) + return self._wait(adapter.query_lookup_and_lock_result, task_id, len(keys)) + + def load(self, adapter, keys, objects): + task_id = adapter.submit_load_task(keys, objects) + return self._wait(adapter.query_load_result, task_id, len(keys)) + + def _wait(self, query, task_id, count): + deadline = time.time() + 10 + while time.time() < deadline: + bitmap = query(task_id) + if bitmap is not None: + self.assertIsNone(query(task_id), "results must be returned once") + return [bitmap.test(i) for i in range(count)] + time.sleep(0.005) + self.fail("task did not finish") + + def test_round_trip_across_chunks(self): + key = Key(b"\x01\x02") + data = payload(CHUNK_SIZE * 2 + 8192) + self.assertEqual(self.store(self.adapter, [key], [Obj(data)]), len(data)) + self.assertEqual(self.lookup(self.adapter, [key, Key(b"\x09")]), [True, False]) + + target = Obj(bytes(len(data))) + self.assertEqual(self.load(self.adapter, [key], [target]), [True]) + self.assertEqual(bytes(target.byte_array), data) + + commit = self.daemon.actions("commit_write")[0] + self.assertTrue(commit["local_only"]) + self.assertEqual(len(commit["chunk_checksums"]), 3) + self.assertFalse(self.daemon.actions("stage_write")[0]["auto_flush_s3"]) + + @unittest.skipIf(HAVE_LMCACHE, "inspects the stub's event log") + def test_notifies_only_real_changes(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + self.store(self.adapter, [key], [Obj(payload(8192))]) + self.assertEqual(self.adapter.events["stored"], [key]) + self.load(self.adapter, [key, Key(b"\x02")], [Obj(bytes(8192)), Obj(bytes(8192))]) + self.assertEqual(self.adapter.events["accessed"], [key]) + + def test_event_fds_are_distinct_and_fire(self): + fds = { + self.adapter.get_store_event_fd(), + self.adapter.get_lookup_and_lock_event_fd(), + self.adapter.get_load_event_fd(), + } + self.assertEqual(len(fds), 3) + self.adapter.submit_lookup_and_lock_task([Key(b"\x01")], {}) + ready, _, _ = select.select([self.adapter.get_lookup_and_lock_event_fd()], [], [], 5) + self.assertTrue(ready) + + def test_key_fields_isolate_blocks(self): + base = Key(b"\xaa", cache_salt="tenant-a") + self.store(self.adapter, [base], [Obj(payload(8192))]) + others = [ + Key(b"\xab", cache_salt="tenant-a"), + Key(b"\xaa", cache_salt="tenant-b"), + Key(b"\xaa", cache_salt=""), + Key(b"\xaa", model_name="org/other", cache_salt="tenant-a"), + Key(b"\xaa", kv_rank=1, cache_salt="tenant-a"), + Key(b"\xaa", object_group_id=1, cache_salt="tenant-a"), + ] + self.assertEqual(self.lookup(self.adapter, others), [False] * len(others)) + self.assertEqual(self.lookup(self.adapter, [base]), [True]) + + def test_no_salt_cannot_collide_with_any_salt(self): + self.store(self.adapter, [Key(b"\xaa")], [Obj(payload(8192))]) + self.assertEqual(self.lookup(self.adapter, [Key(b"\xaa", cache_salt="_")]), [False]) + + def test_model_name_cannot_add_path_levels(self): + uri = self.adapter._uri(Key(b"\x01", model_name="a/b/../c", cache_salt="x/y")) + self.assertEqual(uri.count("/"), len("hypercache://kv_cache/ns/m/r/g/s/h".split("/")) - 1) + + def test_changed_namespace_misses(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + other = self.make_adapter(namespace="ns2") + self.addCleanup(other.close) + self.assertEqual(self.lookup(other, [key]), [False]) + + def test_namespace_is_required(self): + with self.assertRaises(ValueError): + HyperCacheL2AdapterConfig.from_dict({"socket_path": "/tmp/x"}) + + def test_corrupt_block_is_a_miss_and_evicted(self): + key = Key(b"\x01") + data = payload(CHUNK_SIZE + 4096) + self.store(self.adapter, [key], [Obj(data)]) + self.daemon.corrupt(self.adapter._uri(key), chunk_index=1) + + self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(len(data)))]), [False]) + self.assertEqual(self.lookup(self.adapter, [key]), [False]) + self.assertEqual(self.adapter.report_status()["checksum_failures"], 1) + + def test_one_bad_key_does_not_fail_the_others(self): + good, bad = Key(b"\x01"), Key(b"\x02") + self.store(self.adapter, [good, bad], [Obj(payload(8192)), Obj(payload(8192, seed=3))]) + self.daemon.corrupt(self.adapter._uri(bad)) + targets = [Obj(bytes(8192)), Obj(bytes(8192))] + self.assertEqual(self.load(self.adapter, [good, bad], targets), [True, False]) + self.assertEqual(bytes(targets[0].byte_array), payload(8192)) + + def test_wrong_buffer_size_is_a_miss_and_keeps_the_block(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(4096))]), [False]) + self.assertEqual(self.lookup(self.adapter, [key]), [True]) + + def test_block_replaced_during_read_is_not_evicted(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + uri = self.adapter._uri(key) + self.daemon.corrupt(uri) + + class ReplacingReader: + def __init__(self, reader, daemon): + self.reader, self.daemon = reader, daemon + + def read_range_into(self, *args): + try: + return self.reader.read_range_into(*args) + finally: + self.daemon.objects[uri]["generation"] += 1 + + def close(self): + self.reader.close() + + self.adapter._reader = ReplacingReader(self.adapter._reader, self.daemon) + self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(8192))]), [False]) + self.assertIn(uri, self.daemon.objects) + + def test_uncommitted_and_unchecked_blocks_are_misses(self): + key = Key(b"\x01") + uri = self.adapter._uri(key) + client = self.adapter._client() + client.stage_write(uri, 8192, auto_flush_s3=False) + self.assertEqual(self.lookup(self.adapter, [key]), [False]) + self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(8192))]), [False]) + + client.commit_write(uri, local_only=True) + self.assertEqual(self.lookup(self.adapter, [key]), [False], "no checksums") + + def test_interrupted_store_can_be_retried(self): + key = Key(b"\x01") + self.adapter._client().stage_write(self.adapter._uri(key), 8192, auto_flush_s3=False) + self.assertEqual(self.store(self.adapter, [key], [Obj(payload(8192))]), 8192) + self.assertEqual(self.lookup(self.adapter, [key]), [True]) + + def test_older_daemon_is_refused_before_any_write(self): + self.daemon.reports_sync_status = False + key = Key(b"\x01") + self.assertEqual(self.store(self.adapter, [key], [Obj(payload(8192))]), -1) + self.assertEqual(self.daemon.actions("commit_write"), []) + self.assertEqual(self.daemon.objects, {}) + self.assertEqual(self.lookup(self.adapter, [key]), [False]) + + def test_failed_write_fails_the_task_and_cleans_up(self): + def fail(*_): + raise OSError("disk error") + + self.adapter._writer.write_chunks = fail + self.assertEqual(self.store(self.adapter, [Key(b"\x01")], [Obj(payload(8192))]), -1) + self.assertEqual(self.daemon.objects, {}) + self.assertEqual(self.daemon.actions("commit_write"), []) + + def test_delete_skips_locked_blocks_until_unlocked(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + self.lookup(self.adapter, [key]) + self.lookup(self.adapter, [key]) + + self.adapter.delete([key]) + self.assertEqual(len(self.daemon.objects), 1) + self.adapter.submit_unlock([key]) + self.adapter.delete([key]) + self.assertEqual(len(self.daemon.objects), 1) + self.adapter.submit_unlock([key]) + self.adapter.delete([key]) + self.assertEqual(self.daemon.objects, {}) + + def test_unlock_of_unknown_key_is_harmless(self): + self.adapter.submit_unlock([Key(b"\x77")]) + self.assertEqual(self.adapter.report_status()["locked_keys"], 0) + + def test_daemon_down_means_misses_and_failed_stores(self): + key = Key(b"\x01") + self.store(self.adapter, [key], [Obj(payload(8192))]) + self.adapter.close() + self.daemon.stop() + + adapter = self.make_adapter() + self.adapter = adapter + self.addCleanup(adapter.close) + self.assertEqual(self.lookup(adapter, [key]), [False]) + self.assertEqual(self.load(adapter, [key], [Obj(bytes(8192))]), [False]) + self.assertEqual(self.store(adapter, [key], [Obj(payload(8192))]), -1) + adapter.submit_unlock([key]) + self.assertFalse(adapter.report_status()["is_healthy"]) + + def test_concurrent_stores_of_the_same_key_stay_readable(self): + key = Key(b"\x01") + objects = [Obj(payload(8192)) for _ in range(16)] + self.store(self.adapter, [key] * 16, objects) + target = Obj(bytes(8192)) + self.assertEqual(self.load(self.adapter, [key], [target]), [True]) + self.assertEqual(bytes(target.byte_array), payload(8192)) + + +class KVStoreLocalOnlyTest(unittest.TestCase): + def setUp(self): + self.directory = tempfile.mkdtemp(prefix="hckv", dir="/tmp") + self.addCleanup(shutil.rmtree, self.directory, ignore_errors=True) + self.daemon = FakeDaemon(self.directory) + + def test_commit_is_local_only_and_staged_blocks_are_misses(self): + from hypercache.kv_store import HyperCacheKVStore + + store = HyperCacheKVStore(socket_path=self.daemon.socket_path, default_tier="nvme", prefer_gds=False) + self.addCleanup(store.close) + block = payload(8192) + self.assertTrue(store.put_kv_block("committed", block)) + self.assertTrue(self.daemon.actions("commit_write")[0]["local_only"]) + self.assertEqual(bytes(store.get_kv_block("committed")), block) + + store._client.stage_write(store._make_uri("staged"), 8192) + self.assertFalse(store.exists_kv_block("staged")) + self.assertIsNone(store.get_kv_block("staged")) + + +if __name__ == "__main__": + unittest.main() diff --git a/control-plane/src/protocol.rs b/control-plane/src/protocol.rs index ae18de6..aebfc17 100644 --- a/control-plane/src/protocol.rs +++ b/control-plane/src/protocol.rs @@ -91,6 +91,12 @@ pub enum Request { sha256: Option, #[serde(default)] write_through: bool, + /// Keep the object on this host only: no backend flush, and evictable once committed. + #[serde(default)] + local_only: bool, + /// Per-chunk CRC32 values computed by the client, in layout order. + #[serde(default)] + chunk_checksums: Option>, }, Pin { uri: String, @@ -156,6 +162,9 @@ pub enum SyncStatus { SyncFailed, #[serde(rename = "REPLICA_COMMITTED")] ReplicaCommitted, + /// Regenerable data with no authoritative copy, such as a KV cache block. Never flushed. + #[serde(rename = "LOCAL_ONLY")] + LocalOnly, } impl SyncStatus { @@ -176,6 +185,7 @@ impl SyncStatus { SyncStatus::SyncedBackend => "SYNCED_BACKEND", SyncStatus::SyncFailed => "SYNC_FAILED", SyncStatus::ReplicaCommitted => "REPLICA_COMMITTED", + SyncStatus::LocalOnly => "LOCAL_ONLY", } } @@ -185,7 +195,7 @@ impl SyncStatus { SyncStatus::Committed => 50.0, SyncStatus::SyncingBackend => 75.0, SyncStatus::SyncFailed => 0.0, - SyncStatus::SyncedBackend | SyncStatus::ReplicaCommitted => 100.0, + SyncStatus::SyncedBackend | SyncStatus::ReplicaCommitted | SyncStatus::LocalOnly => 100.0, } } } @@ -280,6 +290,11 @@ impl Response { self } + pub fn with_sync_status(mut self, sync_status: Option) -> Self { + self.sync_status = sync_status; + self + } + pub fn devices(devices: Vec, ram_cache_enabled: bool, ram_capacity_bytes: Option) -> Self { Self { status: ResponseStatus::Devices, diff --git a/control-plane/src/server.rs b/control-plane/src/server.rs index 2a55774..4c4ad47 100644 --- a/control-plane/src/server.rs +++ b/control-plane/src/server.rs @@ -280,7 +280,19 @@ impl Server { uri, sha256, write_through, - }) => self.handle_commit_write(&uri, sha256, write_through, t_start).await, + local_only, + chunk_checksums, + }) => { + if local_only { + if write_through { + Response::error("local_only and write_through cannot be combined".to_string()) + } else { + self.handle_commit_local_only(&uri, chunk_checksums, t_start).await + } + } else { + self.handle_commit_write(&uri, sha256, write_through, t_start).await + } + } Ok(Request::GetWriteStatus { uri }) => self.handle_get_write_status(&uri).await, Ok(Request::PreloadBatch { uris, tier }) => self.handle_preload_batch(uris, tier, t_start).await, Ok(Request::RecordTelemetry { @@ -370,7 +382,9 @@ impl Server { let _ = self.metadata.set_pinned(uri, true).await; } self.record_event("CACHE_HIT", "HIT", uri, meta.object_size, &meta.chunk_layout, t_start); - Response::hit(meta.object_size, meta.chunk_size, meta.chunk_layout).with_generation(meta.generation) + Response::hit(meta.object_size, meta.chunk_size, meta.chunk_layout) + .with_generation(meta.generation) + .with_sync_status(meta.sync_status) } Ok(None) => { self.record_event("CACHE_MISS", "MISS", uri, 0, &[], t_start); @@ -603,6 +617,51 @@ impl Server { Response::write_committed(uri.to_string(), size) } + /// Commits a staged object that has no authoritative copy. Its data is synced to the cache + /// device, but it is never flushed to a backend and stays evictable. + async fn handle_commit_local_only( + &self, + uri: &str, + chunk_checksums: Option>, + t_start: Instant, + ) -> Response { + let meta = match self.metadata.get_layout(uri).await { + Ok(Some(meta)) => meta, + Ok(None) => return Response::error(format!("URI '{}' was not staged prior to commit", uri)), + Err(e) => return Response::error(format!("Metadata lookup failed for commit: {}", e)), + }; + if let Err(e) = verify_ram_chunks_written(&meta.chunk_layout) { + error!("Commit of '{}' rejected: {:#}", uri, e); + return Response::error(format!("{:#}", e)); + } + if let Err(e) = self.ingestion.striper().sync_chunks(&meta.chunk_layout).await { + return Response::error(format!("Failed to flush staged data to stable storage: {:#}", e)); + } + if let Some(crcs) = chunk_checksums { + if !self.metadata.set_chunk_checksums(uri, meta.generation, &crcs).await { + return Response::error(format!( + "Could not record {} checksum(s) for '{}': the layout changed or has a different chunk count", + crcs.len(), + uri + )); + } + } + if !self + .metadata + .update_sync_status_if_generation(uri, meta.generation, SyncStatus::LocalOnly) + .await + { + return Response::error(format!("'{}' was replaced or evicted during commit", uri)); + } + info!( + "Committed local-only write for '{}': {} bytes in {:.2} ms.", + uri, + meta.object_size, + t_start.elapsed().as_secs_f64() * 1000.0 + ); + Response::write_committed(uri.to_string(), meta.object_size) + } + /// Flushes a committed object to the authoritative backend in the background, retrying /// with exponential backoff. Status updates are tied to the layout generation so a newer /// write of the same URI is never marked as synced by an older flush. @@ -1064,6 +1123,90 @@ mod tests { } } + #[tokio::test] + async fn test_local_only_commit_is_never_flushed_and_stays_evictable() { + let (server, dir) = nvme_server("local", 16, |config| { + // A flush attempt would be visible: this path would appear under the NFS root. + config.authoritative_backend = "nfs".to_string(); + }); + let uri = "hypercache://kv_cache/model/0/0/_/abc.kv"; + let data: Vec = (0..(2 * 1024 * 1024 + 123)).map(|i| (i % 251) as u8).collect(); + let t = Instant::now(); + + let staged = server + .handle_stage_write(uri, data.len() as u64, None, false, false, false, t) + .await; + let layout = staged.chunk_layout.unwrap(); + write_staged(&server, &layout, &data).await; + + // Before commit, locate reports the staged status so a reader can refuse the object + let before = server.handle_locate(uri, false, None, false, t).await; + assert_eq!(before.sync_status, Some(SyncStatus::Staged)); + + let mut pos = 0usize; + let crcs: Vec = layout + .iter() + .map(|c| { + let crc = crc32fast::hash(&data[pos..pos + c.length as usize]); + pos += c.length as usize; + crc + }) + .collect(); + let committed = server.handle_commit_local_only(uri, Some(crcs.clone()), t).await; + assert_eq!(committed.status, crate::protocol::ResponseStatus::WriteCommitted); + + let after = server.handle_locate(uri, false, None, false, t).await; + assert_eq!(after.sync_status, Some(SyncStatus::LocalOnly)); + let recorded: Vec = after + .chunk_layout + .unwrap() + .iter() + .map(|c| c.checksum.unwrap()) + .collect(); + assert_eq!(recorded, crcs); + + let meta = server.metadata().get_layout(uri).await.unwrap().unwrap(); + assert!(!meta.is_dirty(), "local-only objects must stay evictable"); + assert!(server.metadata().list_dirty_entries().await.is_empty()); + + tokio::time::sleep(Duration::from_millis(200)).await; + let files: Vec<_> = std::fs::read_dir(&dir) + .unwrap() + .map(|e| e.unwrap().file_name()) + .collect(); + assert_eq!( + files, + vec![std::ffi::OsString::from("dev0.raw")], + "no backend flush may run" + ); + assert_eq!( + server.metadata().get_sync_status(uri).await.unwrap(), + Some(SyncStatus::LocalOnly) + ); + std::fs::remove_dir_all(&dir).ok(); + } + + #[tokio::test] + async fn test_local_only_commit_rejects_wrong_checksum_count_and_write_through() { + let (server, dir) = nvme_server("localbad", 16, |_| {}); + let uri = "hypercache://kv_cache/model/0/0/_/bad.kv"; + let t = Instant::now(); + let staged = server.handle_stage_write(uri, 4096, None, false, false, false, t).await; + write_staged(&server, &staged.chunk_layout.unwrap(), &[7u8; 4096]).await; + + let bad = server.handle_commit_local_only(uri, Some(vec![1, 2, 3]), t).await; + assert_eq!(bad.status, crate::protocol::ResponseStatus::Error); + assert_eq!( + server.metadata().get_sync_status(uri).await.unwrap(), + Some(SyncStatus::Staged) + ); + + let line = format!(r#"{{"action":"commit_write","uri":"{uri}","local_only":true,"write_through":true}}"#); + let conflict = server.handle_request_line(&line).await; + assert_eq!(conflict.status, crate::protocol::ResponseStatus::Error); + std::fs::remove_dir_all(&dir).ok(); + } + #[tokio::test] async fn test_commit_verifies_sha256_and_records_checksums() { use sha2::{Digest, Sha256}; diff --git a/scripts/e2e/lmcache_l2_e2e.py b/scripts/e2e/lmcache_l2_e2e.py new file mode 100644 index 0000000..0438fd3 --- /dev/null +++ b/scripts/e2e/lmcache_l2_e2e.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +""" +End-to-end check of the LMCache L2 adapter: real LMCache, real daemon, real device. + +Loads the adapter through LMCache's plugin loader, then checks round trips, restart behaviour, +misses and corruption handling. Needs a running daemon that can write to its device, and read +and write access to that device, because the corruption test damages one stored chunk. + + python3 scripts/e2e/lmcache_l2_e2e.py --socket /run/hc-l2/hc.sock +""" + +import argparse +import hashlib +import json +import mmap +import os +import select +import stat +import sys +import time + +import torch # noqa: F401 # must precede lmcache_native +from lmcache.v1.distributed.api import ObjectKey +from lmcache.v1.distributed.l2_adapters import create_l2_adapter +from lmcache.v1.distributed.l2_adapters.base import L2AdapterInterface +from lmcache.v1.distributed.l2_adapters.plugin_l2_adapter import PluginL2AdapterConfig + +from hypercache.client import HyperCacheClient +from hypercache.datapath import DirectBlockReader, DirectBlockWriter + + +class Obj: + """A buffer with the attribute the adapter and LMCache's file adapter use.""" + + def __init__(self, data): + self.byte_array = memoryview(bytearray(data)) + + +def make_adapter(socket_path, namespace): + config = PluginL2AdapterConfig.from_dict( + { + "type": "plugin", + "module_path": "hypercache.integrations.lmcache_l2", + "class_name": "HyperCacheL2Adapter", + "adapter_params": {"namespace": namespace, "socket_path": socket_path, "tier": "nvme"}, + } + ) + adapter = create_l2_adapter(config) + assert isinstance(adapter, L2AdapterInterface) + return adapter + + +def key(n, salt=""): + return ObjectKey(hashlib.sha256(str(n).encode()).digest(), "Qwen/test-model", 0, 0, salt) + + +def block(n, size): + seed = hashlib.sha256(str(n).encode()).digest() + return (seed * (size // len(seed) + 1))[:size] + + +def wait_store(adapter, task_id): + deadline = time.time() + 60 + while time.time() < deadline: + select.select([adapter.get_store_event_fd()], [], [], 0.1) + done = adapter.pop_completed_store_tasks() + if task_id in done: + return int(done[task_id]) + raise TimeoutError("store") + + +def wait_bits(query, fd, task_id, count): + deadline = time.time() + 60 + while time.time() < deadline: + select.select([fd], [], [], 0.1) + bitmap = query(task_id) + if bitmap is not None: + return [bitmap.test(i) for i in range(count)] + raise TimeoutError("query") + + +def lookup(adapter, keys): + task_id = adapter.submit_lookup_and_lock_task(keys, {}) + return wait_bits(adapter.query_lookup_and_lock_result, adapter.get_lookup_and_lock_event_fd(), task_id, len(keys)) + + +def load(adapter, keys, objects): + task_id = adapter.submit_load_task(keys, objects) + return wait_bits(adapter.query_load_result, adapter.get_load_event_fd(), task_id, len(keys)) + + +def client_device(socket_path, adapter, stored_key): + client = HyperCacheClient(socket_path=socket_path) + try: + return client.locate(adapter._uri(stored_key), auto_ingest=False).chunk_layout[0].device + finally: + client.close() + + +def mixed_writes_are_coherent(client): + """Writes the same extents through each path in turn. Every read must see the latest write.""" + uri = f"hypercache://kv_cache/e2e-mixed-{os.getpid()}/object.kv" + size = 6 * 1024 * 1024 + 123 # two chunks, and a last chunk that isn't a whole number of blocks + layout = client.stage_write(uri, size, tier="nvme", auto_flush_s3=False).chunk_layout + buffered = DirectBlockWriter(max_workers=4) + direct = DirectBlockWriter(max_workers=4, direct_on_block_devices=True) + direct_reader = DirectBlockReader(max_workers=4, verify_checksums=False) + plain = os.open(layout[0].device, os.O_RDONLY) + aligned = mmap.mmap(-1, size) + view = memoryview(aligned) + + def read_both(): + through_direct = bytearray(size) + direct_reader.read_range_into(layout, 0, size, through_direct) + through_cache, position = bytearray(size), 0 + for chunk in layout: + through_cache[position : position + chunk.length] = os.pread(plain, chunk.length, chunk.offset) + position += chunk.length + return bytes(through_direct), bytes(through_cache) + + try: + for round_number, writer in enumerate([buffered, direct, buffered, direct, direct, buffered]): + data = block(1000 + round_number, size) + view[:] = data + writer.write_chunks(layout, view) + if read_both() != (data, data): + return False + return True + finally: + view.release() + os.close(plain) + direct_reader.close() + direct.close() + buffered.close() + client.evict(uri) + + +def check(name, condition): + print(f"{'PASS' if condition else 'FAIL'} {name}", flush=True) + return bool(condition) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--socket", required=True) + parser.add_argument("--size-mb", type=int, default=14, help="object size; 14 MiB is one 256-token Qwen2.5-7B chunk") + args = parser.parse_args() + + size = args.size_mb * 1024 * 1024 + namespace = f"e2e-{os.getpid()}" + results = [] + adapter = make_adapter(args.socket, namespace) + keys = [key(i) for i in range(8)] + + stored = wait_store(adapter, adapter.submit_store_task(keys, [Obj(block(i, size)) for i in range(8)])) + results.append(check("store reports every byte", stored == 8 * size)) + if stat.S_ISBLK(os.stat(client_device(args.socket, adapter, keys[0])).st_mode): + results.append(check("raw device writes use O_DIRECT", any(fd is not None for fd in adapter._writer._direct_fds.values()))) + results.append(check("repeat store writes nothing", wait_store(adapter, adapter.submit_store_task(keys, [Obj(block(i, size)) for i in range(8)])) == 0)) + + results.append(check("lookup finds stored keys only", lookup(adapter, keys + [key(99)]) == [True] * 8 + [False])) + targets = [Obj(bytes(size)) for _ in keys] + results.append(check("load succeeds", load(adapter, keys, targets) == [True] * 8)) + results.append(check("bytes match", all(bytes(t.byte_array) == block(i, size) for i, t in enumerate(targets)))) + adapter.submit_unlock(keys) + + results.append(check("other salt misses", lookup(adapter, [key(0, salt="tenant-b")]) == [False])) + other = make_adapter(args.socket, namespace + "-other") + results.append(check("other namespace misses", lookup(other, keys[:1]) == [False])) + other.close() + + client = HyperCacheClient(socket_path=args.socket) + location = client.locate(adapter._uri(keys[0]), auto_ingest=False) + results.append(check("block is LOCAL_ONLY", location.sync_status == "LOCAL_ONLY")) + results.append(check("every chunk has a checksum", all(c.checksum is not None for c in location.chunk_layout))) + + # Damage one byte on the device, as a bad sector or a stale layout would + chunk = location.chunk_layout[-1] + fd = os.open(chunk.device, os.O_RDWR) + try: + position = chunk.offset + chunk.length // 2 + original = os.pread(fd, 1, position) + os.pwrite(fd, bytes([original[0] ^ 0xFF]), position) + os.fsync(fd) + finally: + os.close(fd) + damaged = [Obj(bytes(size))] + results.append(check("corrupt block is a miss", load(adapter, keys[:1], damaged) == [False])) + results.append(check("corrupt block is removed", lookup(adapter, keys[:1]) == [False])) + results.append(check("other blocks still load", load(adapter, keys[1:2], [Obj(bytes(size))]) == [True])) + adapter.submit_unlock(keys[1:2]) + results.append(check("status counts the checksum failure", adapter.report_status()["checksum_failures"] == 1)) + + wrong = load(adapter, keys[1:2], [Obj(bytes(size - 4096))]) + results.append(check("wrong buffer size is a miss", wrong == [False])) + + results.append(check("page cache and O_DIRECT stay coherent on one device", mixed_writes_are_coherent(client))) + + adapter.delete(keys) + adapter.submit_unlock(keys) + adapter.delete(keys) + results.append(check("delete removes blocks", lookup(adapter, keys) == [False] * 8)) + results.append(check("status is healthy", adapter.report_status()["is_healthy"] is True)) + adapter.close() + client.close() + + passed = sum(results) + print(json.dumps({"passed": passed, "total": len(results)})) + return 0 if passed == len(results) else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/e2e/lmcache_vllm_e2e.py b/scripts/e2e/lmcache_vllm_e2e.py new file mode 100644 index 0000000..8abe045 --- /dev/null +++ b/scripts/e2e/lmcache_vllm_e2e.py @@ -0,0 +1,24 @@ +"""Sends a long prompt twice; between sends L1 is flushed by volume, so the second must come from L2.""" +import json,sys,time,urllib.request +URL="http://127.0.0.1:18111/v1/completions"; M="Qwen/Qwen2.5-7B-Instruct-AWQ" +def ask(prompt): + body=json.dumps({"model":M,"prompt":prompt,"max_tokens":24,"temperature":0,"stream":True}).encode() + req=urllib.request.Request(URL,body,{"Content-Type":"application/json"}); t=time.time(); first=None; text="" + with urllib.request.urlopen(req,timeout=300) as r: + for line in r: + line=line.decode().strip() + if not line.startswith("data:") or line.endswith("[DONE]"): continue + c=json.loads(line[5:])["choices"][0]["text"] + if c and first is None: first=time.time()-t + text+=c + return first,text +base=" ".join(f"Item {i} in the inventory has the serial code {i*7919%10007} and is stored on shelf {i%37}." for i in range(380)) +out={} +out["cold"]=ask("A: "+base+"\nSummary:") +out["warm"]=ask("A: "+base+"\nSummary:") +for n in range(int(sys.argv[1])): + ask(f"Filler {n}: "+" ".join(f"Record {n}-{i} has value {i*n%991}." for i in range(800))) +time.sleep(20) # let L1 eviction get below its watermark, so the load has room +out["after_l1_flush"]=ask("A: "+base+"\nSummary:") +for k,v in out.items(): print(k,f"ttft={v[0]:.3f}s",repr(v[1][:70])) +print("identical_output",out["cold"][1]==out["warm"][1]==out["after_l1_flush"][1]) From 22e7a6a946b81962785b7146c73d80174a038910 Mon Sep 17 00:00:00 2001 From: neo-th Date: Tue, 3 Nov 2026 01:12:25 -0600 Subject: [PATCH 2/9] Replace the LMCache Python adapter with a Rust connector Add lmcache-connector/, an L2 connector loaded through LMCache's native_plugin type, and remove hypercache.integrations.lmcache_l2 with its unit tests and the hypercache[lmcache] extra. The Python adapter never shipped in a release and remains at 5108dcc. The connector does its I/O in worker threads without the interpreter lock, and defaults to 32 workers per direction. On a Xeon VM with 4 network disks it loaded at 6.4 GB/s against 2.8 GB/s for Python, and at 39.8 GB/s against 9.4 GB/s from the RAM tier. On one drive the two tie, because the drive sets the limit. The end-to-end script now tests only this connector. Checks that shared blocks with the Python adapter become checks on the URI format. Known open issue: temperature-0 output sometimes differs after a cache hit, including with LMCache L1 only and no HyperCache. See benchmarks/results/lmcache_rust_connector_xeon.md. --- AGENTS.md | 3 +- CHANGELOG.md | 9 +- README.md | 15 +- benchmarks/lmcache_connector_direct.py | 92 ++ benchmarks/results/lmcache_and_ttft.md | 2 + .../baseline/read_1M_q64_all.json | 316 +++++ .../baseline/read_4M_q16_all.json | 316 +++++ .../baseline/read_4M_q16_vdc.json | 277 ++++ .../baseline/read_4M_q16_vdd.json | 277 ++++ .../baseline/read_4M_q16_vde.json | 277 ++++ .../baseline/read_4M_q16_vdf.json | 277 ++++ .../baseline/read_4M_q1_vdc.json | 277 ++++ .../baseline/read_4M_q64_all.json | 316 +++++ .../baseline/write_4M_q16_all.json | 316 +++++ .../baseline/write_4M_q16_vdc.json | 276 ++++ .../baseline/write_4M_q16_vdd.json | 276 ++++ .../baseline/write_4M_q16_vde.json | 276 ++++ .../baseline/write_4M_q16_vdf.json | 276 ++++ .../baseline/write_4M_q64_all.json | 316 +++++ .../rust-connector-xeon/baseline2/memory.txt | 24 + .../rust-connector-xeon/baseline2/r1_1.json | 277 ++++ .../rust-connector-xeon/baseline2/r1_2.json | 277 ++++ .../rust-connector-xeon/baseline2/r1_3.json | 277 ++++ .../rust-connector-xeon/baseline2/r2_1.json | 290 ++++ .../rust-connector-xeon/baseline2/r2_2.json | 290 ++++ .../rust-connector-xeon/baseline2/r2_3.json | 290 ++++ .../rust-connector-xeon/baseline2/r2b.json | 290 ++++ .../rust-connector-xeon/baseline2/r3_1.json | 303 ++++ .../rust-connector-xeon/baseline2/r3_2.json | 303 ++++ .../rust-connector-xeon/baseline2/r3_3.json | 303 ++++ .../rust-connector-xeon/baseline2/r4_1.json | 316 +++++ .../rust-connector-xeon/baseline2/r4_2.json | 316 +++++ .../rust-connector-xeon/baseline2/r4_3.json | 316 +++++ .../rust-connector-xeon/baseline2/w1_1.json | 277 ++++ .../rust-connector-xeon/baseline2/w1_2.json | 277 ++++ .../rust-connector-xeon/baseline2/w1_3.json | 277 ++++ .../rust-connector-xeon/baseline2/w1b.json | 277 ++++ .../rust-connector-xeon/baseline2/w2_1.json | 290 ++++ .../rust-connector-xeon/baseline2/w2_2.json | 290 ++++ .../rust-connector-xeon/baseline2/w2_3.json | 290 ++++ .../rust-connector-xeon/baseline2/w2b.json | 290 ++++ .../rust-connector-xeon/baseline2/w3_1.json | 303 ++++ .../rust-connector-xeon/baseline2/w3_2.json | 303 ++++ .../rust-connector-xeon/baseline2/w3_3.json | 303 ++++ .../rust-connector-xeon/baseline2/w4_1.json | 316 +++++ .../rust-connector-xeon/baseline2/w4_2.json | 316 +++++ .../rust-connector-xeon/baseline2/w4_3.json | 316 +++++ .../full/d1_if16/python_w16-1.cpu | 1 + .../full/d1_if16/python_w16-1.json | 73 + .../full/d1_if16/python_w16-2.cpu | 1 + .../full/d1_if16/python_w16-2.json | 73 + .../full/d1_if16/python_w16-3.cpu | 1 + .../full/d1_if16/python_w16-3.json | 73 + .../full/d1_if16/python_w8-1.cpu | 1 + .../full/d1_if16/python_w8-1.json | 73 + .../full/d1_if16/python_w8-2.cpu | 1 + .../full/d1_if16/python_w8-2.json | 73 + .../full/d1_if16/python_w8-3.cpu | 1 + .../full/d1_if16/python_w8-3.json | 73 + .../full/d1_if16/raw_block_w16-1.cpu | 1 + .../full/d1_if16/raw_block_w16-1.json | 73 + .../full/d1_if16/raw_block_w16-2.cpu | 1 + .../full/d1_if16/raw_block_w16-2.json | 73 + .../full/d1_if16/raw_block_w16-3.cpu | 1 + .../full/d1_if16/raw_block_w16-3.json | 73 + .../full/d1_if16/raw_block_w32-1.cpu | 1 + .../full/d1_if16/raw_block_w32-1.json | 73 + .../full/d1_if16/raw_block_w32-2.cpu | 1 + .../full/d1_if16/raw_block_w32-2.json | 73 + .../full/d1_if16/raw_block_w32-3.cpu | 1 + .../full/d1_if16/raw_block_w32-3.json | 73 + .../full/d1_if16/raw_block_w8-1.cpu | 1 + .../full/d1_if16/raw_block_w8-1.json | 73 + .../full/d1_if16/raw_block_w8-2.cpu | 1 + .../full/d1_if16/raw_block_w8-2.json | 73 + .../full/d1_if16/raw_block_w8-3.cpu | 1 + .../full/d1_if16/raw_block_w8-3.json | 73 + .../full/d1_if16/rust_w16-1.cpu | 1 + .../full/d1_if16/rust_w16-1.json | 73 + .../full/d1_if16/rust_w16-2.cpu | 1 + .../full/d1_if16/rust_w16-2.json | 73 + .../full/d1_if16/rust_w16-3.cpu | 1 + .../full/d1_if16/rust_w16-3.json | 73 + .../full/d1_if16/rust_w32-1.cpu | 1 + .../full/d1_if16/rust_w32-1.json | 73 + .../full/d1_if16/rust_w32-2.cpu | 1 + .../full/d1_if16/rust_w32-2.json | 73 + .../full/d1_if16/rust_w32-3.cpu | 1 + .../full/d1_if16/rust_w32-3.json | 73 + .../full/d1_if16/rust_w8-1.cpu | 1 + .../full/d1_if16/rust_w8-1.json | 73 + .../full/d1_if16/rust_w8-2.cpu | 1 + .../full/d1_if16/rust_w8-2.json | 73 + .../full/d1_if16/rust_w8-3.cpu | 1 + .../full/d1_if16/rust_w8-3.json | 73 + .../full/d1_if4/python_w8-1.cpu | 1 + .../full/d1_if4/python_w8-1.json | 73 + .../full/d1_if4/python_w8-2.cpu | 1 + .../full/d1_if4/python_w8-2.json | 73 + .../full/d1_if4/python_w8-3.cpu | 1 + .../full/d1_if4/python_w8-3.json | 73 + .../full/d1_if4/raw_block_w8-1.cpu | 1 + .../full/d1_if4/raw_block_w8-1.json | 73 + .../full/d1_if4/raw_block_w8-2.cpu | 1 + .../full/d1_if4/raw_block_w8-2.json | 73 + .../full/d1_if4/raw_block_w8-3.cpu | 1 + .../full/d1_if4/raw_block_w8-3.json | 73 + .../full/d1_if4/rust_w8-1.cpu | 1 + .../full/d1_if4/rust_w8-1.json | 73 + .../full/d1_if4/rust_w8-2.cpu | 1 + .../full/d1_if4/rust_w8-2.json | 73 + .../full/d1_if4/rust_w8-3.cpu | 1 + .../full/d1_if4/rust_w8-3.json | 73 + .../full/d2_if16/python_w16-1.cpu | 1 + .../full/d2_if16/python_w16-1.json | 73 + .../full/d2_if16/python_w16-2.cpu | 1 + .../full/d2_if16/python_w16-2.json | 73 + .../full/d2_if16/python_w16-3.cpu | 1 + .../full/d2_if16/python_w16-3.json | 73 + .../full/d2_if16/python_w32-1.cpu | 1 + .../full/d2_if16/python_w32-1.json | 73 + .../full/d2_if16/python_w32-2.cpu | 1 + .../full/d2_if16/python_w32-2.json | 73 + .../full/d2_if16/python_w32-3.cpu | 1 + .../full/d2_if16/python_w32-3.json | 73 + .../full/d2_if16/rust_w16-1.cpu | 1 + .../full/d2_if16/rust_w16-1.json | 73 + .../full/d2_if16/rust_w16-2.cpu | 1 + .../full/d2_if16/rust_w16-2.json | 73 + .../full/d2_if16/rust_w16-3.cpu | 1 + .../full/d2_if16/rust_w16-3.json | 73 + .../full/d2_if16/rust_w32-1.cpu | 1 + .../full/d2_if16/rust_w32-1.json | 73 + .../full/d2_if16/rust_w32-2.cpu | 1 + .../full/d2_if16/rust_w32-2.json | 73 + .../full/d2_if16/rust_w32-3.cpu | 1 + .../full/d2_if16/rust_w32-3.json | 73 + .../full/d2_if16/rust_w64-1.cpu | 1 + .../full/d2_if16/rust_w64-1.json | 73 + .../full/d2_if16/rust_w64-2.cpu | 1 + .../full/d2_if16/rust_w64-2.json | 73 + .../full/d2_if16/rust_w64-3.cpu | 1 + .../full/d2_if16/rust_w64-3.json | 73 + .../full/d4_if16/python_w64-1.cpu | 1 + .../full/d4_if16/python_w64-1.json | 73 + .../full/d4_if16/python_w64-2.cpu | 1 + .../full/d4_if16/python_w64-2.json | 73 + .../full/d4_if16/python_w64-3.cpu | 1 + .../full/d4_if16/python_w64-3.json | 73 + .../full/d4_if16/python_w8-1.cpu | 1 + .../full/d4_if16/python_w8-1.json | 73 + .../full/d4_if16/python_w8-2.cpu | 1 + .../full/d4_if16/python_w8-2.json | 73 + .../full/d4_if16/python_w8-3.cpu | 1 + .../full/d4_if16/python_w8-3.json | 73 + .../full/d4_if16/rust_w128-1.cpu | 1 + .../full/d4_if16/rust_w128-1.json | 73 + .../full/d4_if16/rust_w128-2.cpu | 1 + .../full/d4_if16/rust_w128-2.json | 73 + .../full/d4_if16/rust_w128-3.cpu | 1 + .../full/d4_if16/rust_w128-3.json | 73 + .../full/d4_if16/rust_w16-1.cpu | 1 + .../full/d4_if16/rust_w16-1.json | 73 + .../full/d4_if16/rust_w16-2.cpu | 1 + .../full/d4_if16/rust_w16-2.json | 73 + .../full/d4_if16/rust_w16-3.cpu | 1 + .../full/d4_if16/rust_w16-3.json | 73 + .../full/d4_if16/rust_w32-1.cpu | 1 + .../full/d4_if16/rust_w32-1.json | 73 + .../full/d4_if16/rust_w32-2.cpu | 1 + .../full/d4_if16/rust_w32-2.json | 73 + .../full/d4_if16/rust_w32-3.cpu | 1 + .../full/d4_if16/rust_w32-3.json | 73 + .../full/d4_if16/rust_w64-1.cpu | 1 + .../full/d4_if16/rust_w64-1.json | 73 + .../full/d4_if16/rust_w64-2.cpu | 1 + .../full/d4_if16/rust_w64-2.json | 73 + .../full/d4_if16/rust_w64-3.cpu | 1 + .../full/d4_if16/rust_w64-3.json | 73 + .../full/ram_if16/python_w16-1.cpu | 1 + .../full/ram_if16/python_w16-1.json | 73 + .../full/ram_if16/python_w16-2.cpu | 1 + .../full/ram_if16/python_w16-2.json | 73 + .../full/ram_if16/python_w16-3.cpu | 1 + .../full/ram_if16/python_w16-3.json | 73 + .../full/ram_if16/python_w32-1.cpu | 1 + .../full/ram_if16/python_w32-1.json | 73 + .../full/ram_if16/python_w32-2.cpu | 1 + .../full/ram_if16/python_w32-2.json | 73 + .../full/ram_if16/python_w32-3.cpu | 1 + .../full/ram_if16/python_w32-3.json | 73 + .../full/ram_if16/python_w8-1.cpu | 1 + .../full/ram_if16/python_w8-1.json | 73 + .../full/ram_if16/python_w8-2.cpu | 1 + .../full/ram_if16/python_w8-2.json | 73 + .../full/ram_if16/python_w8-3.cpu | 1 + .../full/ram_if16/python_w8-3.json | 73 + .../full/ram_if16/rust_w16-1.cpu | 1 + .../full/ram_if16/rust_w16-1.json | 73 + .../full/ram_if16/rust_w16-2.cpu | 1 + .../full/ram_if16/rust_w16-2.json | 73 + .../full/ram_if16/rust_w16-3.cpu | 1 + .../full/ram_if16/rust_w16-3.json | 73 + .../full/ram_if16/rust_w32-1.cpu | 1 + .../full/ram_if16/rust_w32-1.json | 73 + .../full/ram_if16/rust_w32-2.cpu | 1 + .../full/ram_if16/rust_w32-2.json | 73 + .../full/ram_if16/rust_w32-3.cpu | 1 + .../full/ram_if16/rust_w32-3.json | 73 + .../full/ram_if16/rust_w64-1.cpu | 1 + .../full/ram_if16/rust_w64-1.json | 73 + .../full/ram_if16/rust_w64-2.cpu | 1 + .../full/ram_if16/rust_w64-2.json | 73 + .../full/ram_if16/rust_w64-3.cpu | 1 + .../full/ram_if16/rust_w64-3.json | 73 + .../full/ram_if16/rust_w8-1.cpu | 1 + .../full/ram_if16/rust_w8-1.json | 73 + .../full/ram_if16/rust_w8-2.cpu | 1 + .../full/ram_if16/rust_w8-2.json | 73 + .../full/ram_if16/rust_w8-3.cpu | 1 + .../full/ram_if16/rust_w8-3.json | 73 + .../scout/d4/python_w16-1.cpu | 1 + .../scout/d4/python_w16-1.json | 73 + .../scout/d4/python_w32-1.cpu | 1 + .../scout/d4/python_w32-1.json | 73 + .../scout/d4/python_w64-1.cpu | 1 + .../scout/d4/python_w64-1.json | 73 + .../scout/d4/python_w8-1.cpu | 1 + .../scout/d4/python_w8-1.json | 73 + .../scout/d4/rust_w16-1.cpu | 1 + .../scout/d4/rust_w16-1.json | 73 + .../scout/d4/rust_w32-1.cpu | 1 + .../scout/d4/rust_w32-1.json | 73 + .../scout/d4/rust_w64-1.cpu | 1 + .../scout/d4/rust_w64-1.json | 73 + .../scout/d4/rust_w8-1.cpu | 1 + .../scout/d4/rust_w8-1.json | 73 + .../scout/ram/python_w16-1.cpu | 1 + .../scout/ram/python_w16-1.json | 73 + .../scout/ram/python_w32-1.cpu | 1 + .../scout/ram/python_w32-1.json | 73 + .../scout/ram/python_w64-1.cpu | 1 + .../scout/ram/python_w64-1.json | 73 + .../scout/ram/python_w64_if64-1.cpu | 1 + .../scout/ram/python_w64_if64-1.json | 73 + .../scout/ram/python_w8-1.cpu | 1 + .../scout/ram/python_w8-1.json | 73 + .../scout/ram/rust_w16-1.cpu | 1 + .../scout/ram/rust_w16-1.json | 73 + .../scout/ram/rust_w32-1.cpu | 1 + .../scout/ram/rust_w32-1.json | 73 + .../scout/ram/rust_w64-1.cpu | 1 + .../scout/ram/rust_w64-1.json | 73 + .../scout/ram/rust_w64_if64-1.cpu | 1 + .../scout/ram/rust_w64_if64-1.json | 73 + .../scout/ram/rust_w8-1.cpu | 1 + .../scout/ram/rust_w8-1.json | 73 + .../rust-connector/drive/python_w4-1.cpu | 1 + .../rust-connector/drive/python_w4-1.json | 73 + .../rust-connector/drive/python_w4-2.cpu | 1 + .../rust-connector/drive/python_w4-2.json | 73 + .../rust-connector/drive/python_w4-3.cpu | 1 + .../rust-connector/drive/python_w4-3.json | 73 + .../drive/python_w4_l1unaligned-1.cpu | 1 + .../drive/python_w4_l1unaligned-1.json | 73 + .../drive/python_w4_l1unaligned-2.cpu | 1 + .../drive/python_w4_l1unaligned-2.json | 73 + .../drive/python_w4_l1unaligned-3.cpu | 1 + .../drive/python_w4_l1unaligned-3.json | 73 + .../rust-connector/drive/python_w8-1.cpu | 1 + .../rust-connector/drive/python_w8-1.json | 73 + .../rust-connector/drive/python_w8-2.cpu | 1 + .../rust-connector/drive/python_w8-2.json | 73 + .../rust-connector/drive/python_w8-3.cpu | 1 + .../rust-connector/drive/python_w8-3.json | 73 + .../rust-connector/drive/raw_block_w8-1.cpu | 1 + .../rust-connector/drive/raw_block_w8-1.json | 73 + .../rust-connector/drive/raw_block_w8-2.cpu | 1 + .../rust-connector/drive/raw_block_w8-2.json | 73 + .../rust-connector/drive/raw_block_w8-3.cpu | 1 + .../rust-connector/drive/raw_block_w8-3.json | 73 + .../rust-connector/drive/rust_w16-1.cpu | 1 + .../rust-connector/drive/rust_w16-1.json | 73 + .../rust-connector/drive/rust_w16-2.cpu | 1 + .../rust-connector/drive/rust_w16-2.json | 73 + .../rust-connector/drive/rust_w16-3.cpu | 1 + .../rust-connector/drive/rust_w16-3.json | 73 + .../rust-connector/drive/rust_w4-1.cpu | 1 + .../rust-connector/drive/rust_w4-1.json | 73 + .../rust-connector/drive/rust_w4-2.cpu | 1 + .../rust-connector/drive/rust_w4-2.json | 73 + .../rust-connector/drive/rust_w4-3.cpu | 1 + .../rust-connector/drive/rust_w4-3.json | 73 + .../rust-connector/drive/rust_w8-1.cpu | 1 + .../rust-connector/drive/rust_w8-1.json | 73 + .../rust-connector/drive/rust_w8-2.cpu | 1 + .../rust-connector/drive/rust_w8-2.json | 73 + .../rust-connector/drive/rust_w8-3.cpu | 1 + .../rust-connector/drive/rust_w8-3.json | 73 + .../drive/rust_w8_l1unaligned-1.cpu | 1 + .../drive/rust_w8_l1unaligned-1.json | 73 + .../drive/rust_w8_l1unaligned-2.cpu | 1 + .../drive/rust_w8_l1unaligned-2.json | 73 + .../drive/rust_w8_l1unaligned-3.cpu | 1 + .../drive/rust_w8_l1unaligned-3.json | 73 + .../rust-connector/ram/python_w16-1.cpu | 1 + .../rust-connector/ram/python_w16-1.json | 73 + .../rust-connector/ram/python_w16-2.cpu | 1 + .../rust-connector/ram/python_w16-2.json | 73 + .../rust-connector/ram/python_w16-3.cpu | 1 + .../rust-connector/ram/python_w16-3.json | 73 + .../rust-connector/ram/python_w4-1.cpu | 1 + .../rust-connector/ram/python_w4-1.json | 73 + .../rust-connector/ram/python_w4-2.cpu | 1 + .../rust-connector/ram/python_w4-2.json | 73 + .../rust-connector/ram/python_w4-3.cpu | 1 + .../rust-connector/ram/python_w4-3.json | 73 + .../rust-connector/ram/python_w8-1.cpu | 1 + .../rust-connector/ram/python_w8-1.json | 73 + .../rust-connector/ram/python_w8-2.cpu | 1 + .../rust-connector/ram/python_w8-2.json | 73 + .../rust-connector/ram/python_w8-3.cpu | 1 + .../rust-connector/ram/python_w8-3.json | 73 + .../rust-connector/ram/rust_w16-1.cpu | 1 + .../rust-connector/ram/rust_w16-1.json | 73 + .../rust-connector/ram/rust_w16-2.cpu | 1 + .../rust-connector/ram/rust_w16-2.json | 73 + .../rust-connector/ram/rust_w16-3.cpu | 1 + .../rust-connector/ram/rust_w16-3.json | 73 + .../rust-connector/ram/rust_w4-1.cpu | 1 + .../rust-connector/ram/rust_w4-1.json | 73 + .../rust-connector/ram/rust_w4-2.cpu | 1 + .../rust-connector/ram/rust_w4-2.json | 73 + .../rust-connector/ram/rust_w4-3.cpu | 1 + .../rust-connector/ram/rust_w4-3.json | 73 + .../rust-connector/ram/rust_w8-1.cpu | 1 + .../rust-connector/ram/rust_w8-1.json | 73 + .../rust-connector/ram/rust_w8-2.cpu | 1 + .../rust-connector/ram/rust_w8-2.json | 73 + .../rust-connector/ram/rust_w8-3.cpu | 1 + .../rust-connector/ram/rust_w8-3.json | 73 + .../rust-connector/ram_if16/python_w16-1.cpu | 1 + .../rust-connector/ram_if16/python_w16-1.json | 73 + .../rust-connector/ram_if16/python_w16-2.cpu | 1 + .../rust-connector/ram_if16/python_w16-2.json | 73 + .../rust-connector/ram_if16/python_w16-3.cpu | 1 + .../rust-connector/ram_if16/python_w16-3.json | 73 + .../rust-connector/ram_if16/python_w32-1.cpu | 1 + .../rust-connector/ram_if16/python_w32-1.json | 73 + .../rust-connector/ram_if16/python_w32-2.cpu | 1 + .../rust-connector/ram_if16/python_w32-2.json | 73 + .../rust-connector/ram_if16/python_w32-3.cpu | 1 + .../rust-connector/ram_if16/python_w32-3.json | 73 + .../rust-connector/ram_if16/rust_w16-1.cpu | 1 + .../rust-connector/ram_if16/rust_w16-1.json | 73 + .../rust-connector/ram_if16/rust_w16-2.cpu | 1 + .../rust-connector/ram_if16/rust_w16-2.json | 73 + .../rust-connector/ram_if16/rust_w16-3.cpu | 1 + .../rust-connector/ram_if16/rust_w16-3.json | 73 + .../rust-connector/ram_if16/rust_w32-1.cpu | 1 + .../rust-connector/ram_if16/rust_w32-1.json | 73 + .../rust-connector/ram_if16/rust_w32-2.cpu | 1 + .../rust-connector/ram_if16/rust_w32-2.json | 73 + .../rust-connector/ram_if16/rust_w32-3.cpu | 1 + .../rust-connector/ram_if16/rust_w32-3.json | 73 + benchmarks/results/lmcache_rust_connector.md | 75 + .../results/lmcache_rust_connector_xeon.md | 117 ++ .../hypercache/integrations/lmcache_l2.py | 427 ------ client-py/hypercache/kv_store.py | 2 +- client-py/pyproject.toml | 3 - client-py/tests/test_lmcache_adapter.py | 484 ------- lmcache-connector/Cargo.lock | 265 ++++ lmcache-connector/Cargo.toml | 23 + lmcache-connector/README.md | 64 + lmcache-connector/pyproject.toml | 16 + lmcache-connector/rustfmt.toml | 1 + lmcache-connector/src/connector.rs | 1248 +++++++++++++++++ lmcache-connector/src/daemon.rs | 169 +++ lmcache-connector/src/io.rs | 564 ++++++++ lmcache-connector/src/key.rs | 118 ++ lmcache-connector/src/lib.rs | 13 + lmcache-connector/src/python.rs | 190 +++ scripts/e2e/lmcache_l2_e2e.py | 140 +- scripts/verify_release.sh | 8 +- 384 files changed, 26940 insertions(+), 940 deletions(-) create mode 100644 benchmarks/lmcache_connector_direct.py create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_1M_q64_all.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_all.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdc.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdd.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vde.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdf.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q1_vdc.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q64_all.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_all.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdc.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdd.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vde.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdf.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q64_all.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/memory.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2b.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1b.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2b.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_rust_connector.md create mode 100644 benchmarks/results/lmcache_rust_connector_xeon.md delete mode 100644 client-py/hypercache/integrations/lmcache_l2.py delete mode 100644 client-py/tests/test_lmcache_adapter.py create mode 100644 lmcache-connector/Cargo.lock create mode 100644 lmcache-connector/Cargo.toml create mode 100644 lmcache-connector/README.md create mode 100644 lmcache-connector/pyproject.toml create mode 100644 lmcache-connector/rustfmt.toml create mode 100644 lmcache-connector/src/connector.rs create mode 100644 lmcache-connector/src/daemon.rs create mode 100644 lmcache-connector/src/io.rs create mode 100644 lmcache-connector/src/key.rs create mode 100644 lmcache-connector/src/lib.rs create mode 100644 lmcache-connector/src/python.rs diff --git a/AGENTS.md b/AGENTS.md index 6fdc72c..74cb4c0 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -93,6 +93,7 @@ hypercache-poc/ │ └── tests/ │ └── s3_live.rs # #[ignore]d live S3 tests (run by scripts/verify_release.sh) │ +├── lmcache-connector/ # LMCache native L2 connector in Rust (PyO3, built with maturin); separate from the daemon ├── scripts/ │ ├── verify_release.sh # Release verification harness (static, rust, python, e2e, s3, linux, image) │ ├── e2e/hypercache_e2e.py # End-to-end daemon / fleet / S3 scenarios against the real binaries @@ -112,7 +113,6 @@ hypercache-poc/ │ ├── kv_store.py # Content-addressed KV-Cache Prefix Block Store │ ├── pipeline.py # In-order byte-range reader with background prefetch; returns bytes, runs no model │ └── integrations/ - │ ├── lmcache_l2.py # LMCache L2 plugin adapter; the only module importing lmcache, never imported by integrations/__init__.py │ ├── safetensors_loader.py # Zero-copy Safetensors & vLLM weight loader │ └── dcp.py # PyTorch Distributed Checkpoint (DCP) StorageReader/Writer └── tests/ @@ -120,7 +120,6 @@ hypercache-poc/ ├── test_fsspec.py # Unit tests for fsspec file operations and streaming writes ├── test_integrations_and_kv.py # Unit tests for Safetensors/vLLM, DCP, and KV-Cache store ├── test_direct_writer.py # DirectBlockWriter O_DIRECT mode: alignment, partial blocks, fallbacks - ├── test_lmcache_adapter.py # LMCache L2 adapter against a fake daemon; stubs LMCache where absent ├── test_pipelined_and_numa.py # Unit tests for pipelined DMA and NUMA affinity └── test_robustness.py # Thread/fork safety, framing, O_DIRECT bounce buffers, CRC verification ``` diff --git a/CHANGELOG.md b/CHANGELOG.md index 5afba96..41be844 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,15 +3,18 @@ ## Unreleased ### Added -- `hypercache.integrations.lmcache_l2`: an L2 adapter for LMCache multiprocess mode, tested on - LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0. Optional extra: `hypercache[lmcache]`. +- `lmcache-connector/`: an L2 connector for LMCache multiprocess mode, written in Rust and loaded + through LMCache's `native_plugin` type. Built separately with maturin. Tested on LMCache 0.5.5 and + 0.5.6 and vLLM 0.31.0 and 0.33.0. - `commit_write` accepts `local_only` and `chunk_checksums`. A `LOCAL_ONLY` object is never flushed to a backend and stays evictable. Both fields are optional on the wire; older clients are unaffected. - `locate` reports `sync_status` for HITs, so a reader can refuse an object that is still staged. - `DirectBlockWriter(direct_on_block_devices=True)` writes to raw block devices with O_DIRECT, falling - back to the page cache for anything it can't take. Off by default; the LMCache adapter turns it on. + back to the page cache for anything it can't take. Off by default. - `benchmarks/pipelined_ttft.py`, `benchmarks/write_concurrency_probe.py`, `benchmarks/raw_write_probe.py` and `benchmarks/results/lmcache_and_ttft.md`. +- `benchmarks/lmcache_connector_direct.py`, `benchmarks/results/lmcache_rust_connector.md` and + `benchmarks/results/lmcache_rust_connector_xeon.md`. ### Fixes - `HyperCacheKVStore` commits are now `LOCAL_ONLY` unless `write_through` is set. Previously every diff --git a/README.md b/README.md index a0a5699..2f3745b 100644 --- a/README.md +++ b/README.md @@ -124,7 +124,7 @@ HyperCache is designed for both **AI Inference** and **Distributed AI Training** * Each node caches only its assigned $1/N$ slice of the dataset and streams batches into local PyTorch `DataLoader` workers at local NVMe line rate with zero network traffic. Because it uses consistent hashing, adding or removing a node only remaps $1/N$ of the shards instead of invalidating the entire cluster cache. ### 5. LLM KV-Cache Prefix Block Offloading (`HyperCacheKVStore`) -* Long-context LLM serving generates massive KV-cache tensors. Rather than recomputing shared prompt prefixes when GPU VRAM fills up, LMCache can keep them on HyperCache through `hypercache.integrations.lmcache_l2`, and other code can use `HyperCacheKVStore` directly. Blocks stay on the local host and remain evictable. There is no NVIDIA Dynamo KVBM integration. +* Long-context LLM serving generates massive KV-cache tensors. Rather than recomputing shared prompt prefixes when GPU VRAM fills up, LMCache can keep them on HyperCache through [`lmcache-connector/`](lmcache-connector/README.md), and other code can use `HyperCacheKVStore` directly. Blocks stay on the local host and remain evictable. There is no NVIDIA Dynamo KVBM integration. ### 6. Peer-to-Peer (P2P) Fleet Distribution * When preloading a large model across a multi-node cluster, you do not want every node pulling the full file from S3 simultaneously. @@ -694,14 +694,15 @@ The loader splits the object by bytes and returns bytes. Your code has to supply ### 6. KV-Cache Storage for LMCache -`hypercache.integrations.lmcache_l2` is an L2 adapter for LMCache's multiprocess mode, tested with LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0. It needs a daemon built from this version or later. Install `hypercache[lmcache]` where the LMCache server runs, and pass: +[`lmcache-connector/`](lmcache-connector/README.md) is an L2 connector for LMCache's multiprocess mode, written in Rust. It's tested with LMCache 0.5.5 and 0.5.6 and vLLM 0.31.0 and 0.33.0, and needs a daemon built from this version or later. Build it with maturin, install the wheel where the LMCache server runs, and pass: ```bash lmcache server --l1-size-gb 60 --eviction-policy LRU --l2-adapter '{ - "type": "plugin", - "module_path": "hypercache.integrations.lmcache_l2", - "class_name": "HyperCacheL2Adapter", - "adapter_params": {"namespace": "my-model-rev-abc123", "tier": "nvme"} + "type": "native_plugin", + "module_path": "hypercache_lmcache_native", + "class_name": "HyperCacheNativeConnector", + "adapter_params": {"namespace": "my-model-rev-abc123", "tier": "nvme"}, + "max_capacity_gb": 0 }' ``` @@ -711,7 +712,7 @@ lmcache server --l1-size-gb 60 --eviction-policy LRU --l2-adapter '{ - **Not supported:** `list_l2_keys` and LMCache's IsolatedLRU quotas. - **Size L1 for loads.** Loads go through L1, and LMCache only evicts it down to 80%. If the load doesn't fit, vLLM recomputes. -See the [results](benchmarks/results/lmcache_and_ttft.md). On our test drive in raw mode, the adapter's loads were within 0.4% of LMCache's `raw_block` adapter and its stores about 4% slower, while also verifying a CRC32 on every chunk. In filesystem arena mode, its loads were within 1% of `fs_native` with O_DIRECT and its stores about 20% slower. +On a single drive, it ties LMCache's `raw_block` adapter on throughput while verifying a CRC32 on every chunk, though `raw_block` lookups are 5 to 10 times as fast. It can also stripe across drives, which `raw_block` can't: on a VM with 4 network disks it loaded at 6.4 GB/s, the VM's read limit, and at 39.8 GB/s from the RAM tier. See the [results](benchmarks/results/lmcache_rust_connector_xeon.md). For code that manages its own KV blocks, use `HyperCacheKVStore`: diff --git a/benchmarks/lmcache_connector_direct.py b/benchmarks/lmcache_connector_direct.py new file mode 100644 index 0000000..417ad7f --- /dev/null +++ b/benchmarks/lmcache_connector_direct.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +""" +Measures the Rust LMCache connector with LMCache out of the path, to find what limits it. + +Calls the connector the way LMCache's wrapper does, with page-aligned buffers. Needs a running +daemon, and the hypercache_lmcache_native package. + + python3 benchmarks/lmcache_connector_direct.py --socket /run/hc/hc.sock --tier ram +""" + +import argparse +import json +import mmap +import os +import select +import time + +from hypercache_lmcache_native import HyperCacheNativeConnector + +OBJECT_SIZE = 14 * 1024 * 1024 +OBJECTS = 64 +BATCH = 8 +MIB = 1024 * 1024 + + +def make_buffers(): + seed = os.urandom(MIB) + buffers = [] + for _ in range(OBJECTS): + view = memoryview(mmap.mmap(-1, OBJECT_SIZE)) + for offset in range(0, OBJECT_SIZE, MIB): + view[offset : offset + MIB] = seed + buffers.append(view) + return buffers + + +def wait(connector, future_ids): + pending = set(future_ids) + all_ok = True + while pending: + select.select([connector.event_fd()], [], [], 1) + for future_id, ok, _error, _results in connector.drain_completions(): + all_ok = all_ok and ok + pending.discard(future_id) + return all_ok + + +def timed(connector, submit, keys, buffers, in_flight_keys): + start = time.perf_counter() + future_ids = [] + all_ok = True + for i in range(0, OBJECTS, BATCH): + if len(future_ids) * BATCH >= in_flight_keys: + all_ok = wait(connector, future_ids) and all_ok + future_ids = [] + future_ids.append(submit(keys[i : i + BATCH], buffers[i : i + BATCH])) + all_ok = wait(connector, future_ids) and all_ok + return OBJECTS * OBJECT_SIZE / 1e6 / (time.perf_counter() - start), all_ok + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--socket", required=True) + parser.add_argument("--tier", default="nvme", choices=["nvme", "ram"]) + args = parser.parse_args() + + buffers = make_buffers() + keys = [f"m@00000000@0@{i:04x}" for i in range(OBJECTS)] + for workers, in_flight_keys in [(4, 64), (8, 64), (16, 64), (32, 64), (16, 8)]: + for repeat in range(2): + namespace = f"direct-{os.getpid()}-{workers}-{in_flight_keys}-{repeat}" + connector = HyperCacheNativeConnector(namespace, args.socket, args.tier, workers) + store, store_ok = timed(connector, connector.submit_batch_set, keys, buffers, in_flight_keys) + load, load_ok = timed(connector, connector.submit_batch_get, keys, buffers, in_flight_keys) + print( + json.dumps( + { + "workers": workers, + "in_flight_keys": in_flight_keys, + "store_mbps": round(store), + "load_mbps": round(load), + "ok": store_ok and load_ok, + } + ), + flush=True, + ) + wait(connector, [connector.submit_batch_delete(keys)]) + connector.close() + + +if __name__ == "__main__": + main() diff --git a/benchmarks/results/lmcache_and_ttft.md b/benchmarks/results/lmcache_and_ttft.md index 47a3568..4f3d4d4 100644 --- a/benchmarks/results/lmcache_and_ttft.md +++ b/benchmarks/results/lmcache_and_ttft.md @@ -1,5 +1,7 @@ # LMCache adapter and pipelined loader results +Note: the Python adapter measured here was later replaced by the Rust connector in `lmcache-connector/`. It remains in git history at commit 5108dcc. + Measured 2026-11-02 on one small server. These results show behaviour and relative cost on this machine. They are not throughput claims for production hardware. **Hardware:** Ryzen 5 5600GT, 31 GB RAM, RTX 4060 Ti 16 GB (PCIe Gen3 x8), Crucial P3 Gen3 x4 (ext4 on LVM), Intel SSDPEKNU512GZ Gen3 x2 (raw, about 1.4 GB/s direct read measured with dd). diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_1M_q64_all.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_1M_q64_all.json new file mode 100644 index 0000000..0a674c0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_1M_q64_all.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675045, + "timestamp_ms" : 1793675045836, + "time" : "Tue Nov 3 03:04:05 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "1M", + "iodepth" : "64", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675020726, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 145963876352, + "io_kbytes" : 142542848, + "bw_bytes" : 5826901251, + "bw" : 5690333, + "iops" : 5556.966068, + "runtime" : 25050, + "total_ios" : 139202, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 12267, + "max" : 1322712, + "mean" : 31281.899549, + "stddev" : 20710.095697, + "N" : 139202 + }, + "clat_ns" : { + "min" : 8761769, + "max" : 109958589, + "mean" : 46006110.448851, + "stddev" : 11073785.565717, + "N" : 139202, + "percentile" : { + "1.000000" : 24248320, + "5.000000" : 29753344, + "10.000000" : 32899072, + "20.000000" : 36962304, + "30.000000" : 39583744, + "40.000000" : 42205184, + "50.000000" : 44826624, + "60.000000" : 47448064, + "70.000000" : 50593792, + "80.000000" : 54788096, + "90.000000" : 60555264, + "95.000000" : 65798144, + "99.000000" : 76021760, + "99.500000" : 80216064, + "99.900000" : 88604672, + "99.950000" : 91750400, + "99.990000" : 99090432 + } + }, + "lat_ns" : { + "min" : 8776598, + "max" : 110010450, + "mean" : 46037392.348400, + "stddev" : 11073229.855352, + "N" : 139202 + }, + "bw_min" : 5062656, + "bw_max" : 6328320, + "bw_agg" : 100.000000, + "bw_mean" : 5691392.000000, + "bw_dev" : 70841.398244, + "bw_samples" : 200, + "iops_min" : 4944, + "iops_max" : 6180, + "iops_mean" : 5558.000000, + "iops_stddev" : 69.181053, + "iops_samples" : 200 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 100194, + "usr_cpu" : 0.965128, + "sys_cpu" : 6.458471, + "ctx" : 74177, + "majf" : 0, + "minf" : 65587, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 0.100000, + ">=64" : 99.818968 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997121, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.100000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.165946, + "50" : 67.384808, + "100" : 32.439189, + "250" : 0.010000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 64, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 51536, + "write_ios" : 0, + "read_sectors" : 70799600, + "write_sectors" : 0, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 2245026, + "write_ticks" : 0, + "in_queue" : 2245025, + "util" : 99.671553 + }, + { + "name" : "vdd", + "read_ios" : 53474, + "write_ios" : 0, + "read_sectors" : 70397928, + "write_sectors" : 0, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 2342560, + "write_ticks" : 0, + "in_queue" : 2342559, + "util" : 99.679539 + }, + { + "name" : "vde", + "read_ios" : 51756, + "write_ios" : 0, + "read_sectors" : 70719448, + "write_sectors" : 0, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 2263463, + "write_ticks" : 0, + "in_queue" : 2263463, + "util" : 99.699507 + }, + { + "name" : "vdf", + "read_ios" : 50458, + "write_ios" : 0, + "read_sectors" : 71394104, + "write_sectors" : 0, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 2187013, + "write_ticks" : 0, + "in_queue" : 2187013, + "util" : 99.703502 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_all.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_all.json new file mode 100644 index 0000000..4929fdb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_all.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674994, + "timestamp_ms" : 1793674994950, + "time" : "Tue Nov 3 03:03:14 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793674969868, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 145408131072, + "io_kbytes" : 142000128, + "bw_bytes" : 5808193771, + "bw" : 5672064, + "iops" : 1384.781306, + "runtime" : 25035, + "total_ios" : 34668, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 51160, + "max" : 1838149, + "mean" : 104493.472655, + "stddev" : 64869.569306, + "N" : 34668 + }, + "clat_ns" : { + "min" : 13415650, + "max" : 98508741, + "mean" : 46076761.525961, + "stddev" : 9914092.526718, + "N" : 34668, + "percentile" : { + "1.000000" : 24772608, + "5.000000" : 30539776, + "10.000000" : 33816576, + "20.000000" : 37486592, + "30.000000" : 40632320, + "40.000000" : 43253760, + "50.000000" : 45875200, + "60.000000" : 48496640, + "70.000000" : 51118080, + "80.000000" : 53739520, + "90.000000" : 58458112, + "95.000000" : 62652416, + "99.000000" : 72876032, + "99.500000" : 76021760, + "99.900000" : 83361792, + "99.950000" : 86507520, + "99.990000" : 93847552 + } + }, + "lat_ns" : { + "min" : 13530771, + "max" : 98670678, + "mean" : 46181254.998615, + "stddev" : 9913415.992145, + "N" : 34668 + }, + "bw_min" : 5095424, + "bw_max" : 6258688, + "bw_agg" : 100.000000, + "bw_mean" : 5672244.453878, + "bw_dev" : 65037.431897, + "bw_samples" : 199, + "iops_min" : 1244, + "iops_max" : 1528, + "iops_mean" : 1384.825306, + "iops_stddev" : 15.878279, + "iops_samples" : 199 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 100124, + "usr_cpu" : 0.435460, + "sys_cpu" : 4.734130, + "ctx" : 26304, + "majf" : 0, + "minf" : 65591, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.826930, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.988443, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.144225, + "50" : 66.461867, + "100" : 33.393908, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 46816, + "write_ios" : 0, + "read_sectors" : 71573176, + "write_sectors" : 0, + "read_merges" : 3319, + "write_merges" : 0, + "read_ticks" : 1722399, + "write_ticks" : 0, + "in_queue" : 1722398, + "util" : 99.691543 + }, + { + "name" : "vdd", + "read_ios" : 45954, + "write_ios" : 0, + "read_sectors" : 70124640, + "write_sectors" : 0, + "read_merges" : 4853, + "write_merges" : 0, + "read_ticks" : 1720414, + "write_ticks" : 0, + "in_queue" : 1720415, + "util" : 99.699531 + }, + { + "name" : "vde", + "read_ios" : 49511, + "write_ios" : 0, + "read_sectors" : 70347840, + "write_sectors" : 0, + "read_merges" : 5445, + "write_merges" : 0, + "read_ticks" : 1831689, + "write_ticks" : 0, + "in_queue" : 1831688, + "util" : 99.715511 + }, + { + "name" : "vdf", + "read_ios" : 47056, + "write_ios" : 0, + "read_sectors" : 70269944, + "write_sectors" : 0, + "read_merges" : 4302, + "write_merges" : 0, + "read_ticks" : 1762453, + "write_ticks" : 0, + "in_queue" : 1762453, + "util" : 99.719506 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdc.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdc.json new file mode 100644 index 0000000..d9b0038 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdc.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674893, + "timestamp_ms" : 1793674893472, + "time" : "Tue Nov 3 03:01:33 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793674868412, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 52688846848, + "io_kbytes" : 51453952, + "bw_bytes" : 2105700857, + "bw" : 2056348, + "iops" : 502.038206, + "runtime" : 25022, + "total_ios" : 12562, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 69553, + "max" : 11272596, + "mean" : 1947434.568699, + "stddev" : 1178304.500536, + "N" : 12562 + }, + "clat_ns" : { + "min" : 6958133, + "max" : 52664495, + "mean" : 29903447.750517, + "stddev" : 4883659.024876, + "N" : 12562, + "percentile" : { + "1.000000" : 10682368, + "5.000000" : 14221312, + "10.000000" : 28442624, + "20.000000" : 29753344, + "30.000000" : 30277632, + "40.000000" : 30539776, + "50.000000" : 31064064, + "60.000000" : 31326208, + "70.000000" : 31588352, + "80.000000" : 32112640, + "90.000000" : 32636928, + "95.000000" : 33161216, + "99.000000" : 38535168, + "99.500000" : 39583744, + "99.900000" : 40632320, + "99.950000" : 41680896, + "99.990000" : 50593792 + } + }, + "lat_ns" : { + "min" : 7095966, + "max" : 54081826, + "mean" : 31850882.319217, + "stddev" : 5115944.157770, + "N" : 12562 + }, + "bw_min" : 1966080, + "bw_max" : 4603904, + "bw_agg" : 100.000000, + "bw_mean" : 2059870.040816, + "bw_dev" : 414189.325311, + "bw_samples" : 49, + "iops_min" : 480, + "iops_max" : 1124, + "iops_mean" : 502.897959, + "iops_stddev" : 101.120441, + "iops_samples" : 49 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 25021, + "usr_cpu" : 0.619480, + "sys_cpu" : 10.071540, + "ctx" : 15075, + "majf" : 0, + "minf" : 16396, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.880592, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.992031, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.477631, + "20" : 6.137558, + "50" : 93.368890, + "100" : 0.015921, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 132863, + "write_ios" : 0, + "read_sectors" : 102400056, + "write_sectors" : 0, + "read_merges" : 2340, + "write_merges" : 0, + "read_ticks" : 3128396, + "write_ticks" : 0, + "in_queue" : 3128396, + "util" : 99.711596 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdd.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdd.json new file mode 100644 index 0000000..9a051f9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdd.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674918, + "timestamp_ms" : 1793674918835, + "time" : "Tue Nov 3 03:01:58 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdd", + "groupid" : 0, + "job_start" : 1793674893766, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 53036974080, + "io_kbytes" : 51793920, + "bw_bytes" : 2119020898, + "bw" : 2069356, + "iops" : 505.213952, + "runtime" : 25029, + "total_ios" : 12645, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 65403, + "max" : 9615525, + "mean" : 1884349.740767, + "stddev" : 1532698.167649, + "N" : 12645 + }, + "clat_ns" : { + "min" : 8644086, + "max" : 54055791, + "mean" : 29763862.714749, + "stddev" : 4397087.609281, + "N" : 12645, + "percentile" : { + "1.000000" : 13172736, + "5.000000" : 17432576, + "10.000000" : 26869760, + "20.000000" : 28704768, + "30.000000" : 29491200, + "40.000000" : 30015488, + "50.000000" : 30539776, + "60.000000" : 31064064, + "70.000000" : 31588352, + "80.000000" : 32374784, + "90.000000" : 33161216, + "95.000000" : 33816576, + "99.000000" : 36438016, + "99.500000" : 37486592, + "99.900000" : 42205184, + "99.950000" : 45350912, + "99.990000" : 51642368 + } + }, + "lat_ns" : { + "min" : 8788840, + "max" : 54210322, + "mean" : 31648212.455516, + "stddev" : 4655917.230810, + "N" : 12645 + }, + "bw_min" : 1974272, + "bw_max" : 3809280, + "bw_agg" : 100.000000, + "bw_mean" : 2072910.367347, + "bw_dev" : 344806.651695, + "bw_samples" : 49, + "iops_min" : 482, + "iops_max" : 930, + "iops_mean" : 506.081633, + "iops_stddev" : 84.181311, + "iops_samples" : 49 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 25028, + "usr_cpu" : 0.695221, + "sys_cpu" : 10.332428, + "ctx" : 13326, + "majf" : 0, + "minf" : 16395, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.881376, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.992083, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.047450, + "20" : 6.571767, + "50" : 93.364966, + "100" : 0.015817, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdd", + "read_ios" : 120378, + "write_ios" : 0, + "read_sectors" : 103068720, + "write_sectors" : 0, + "read_merges" : 3931, + "write_merges" : 0, + "read_ticks" : 3115825, + "write_ticks" : 0, + "in_queue" : 3115824, + "util" : 99.711654 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vde.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vde.json new file mode 100644 index 0000000..9ee3231 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vde.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674944, + "timestamp_ms" : 1793674944201, + "time" : "Tue Nov 3 03:02:24 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vde", + "groupid" : 0, + "job_start" : 1793674919130, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 53036974080, + "io_kbytes" : 51793920, + "bw_bytes" : 2119105564, + "bw" : 2069439, + "iops" : 505.234138, + "runtime" : 25028, + "total_ios" : 12645, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 69697, + "max" : 14408889, + "mean" : 1876366.230763, + "stddev" : 1458045.983634, + "N" : 12645 + }, + "clat_ns" : { + "min" : 8376753, + "max" : 53733952, + "mean" : 29769085.561803, + "stddev" : 4213726.295614, + "N" : 12645, + "percentile" : { + "1.000000" : 14221312, + "5.000000" : 18743296, + "10.000000" : 26345472, + "20.000000" : 28966912, + "30.000000" : 29753344, + "40.000000" : 30277632, + "50.000000" : 30801920, + "60.000000" : 31064064, + "70.000000" : 31588352, + "80.000000" : 32112640, + "90.000000" : 32899072, + "95.000000" : 33816576, + "99.000000" : 36438016, + "99.500000" : 37486592, + "99.900000" : 40108032, + "99.950000" : 45350912, + "99.990000" : 50593792 + } + }, + "lat_ns" : { + "min" : 9483093, + "max" : 53875632, + "mean" : 31645451.792566, + "stddev" : 4476055.728782, + "N" : 12645 + }, + "bw_min" : 1892352, + "bw_max" : 3489792, + "bw_agg" : 99.993234, + "bw_mean" : 2069299.200000, + "bw_dev" : 318093.904513, + "bw_samples" : 50, + "iops_min" : 462, + "iops_max" : 852, + "iops_mean" : 505.200000, + "iops_stddev" : 77.659645, + "iops_samples" : 50 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 25027, + "usr_cpu" : 0.651297, + "sys_cpu" : 10.272905, + "ctx" : 13607, + "majf" : 0, + "minf" : 16395, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.881376, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.992083, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.031633, + "20" : 6.405694, + "50" : 93.538948, + "100" : 0.023725, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vde", + "read_ios" : 120348, + "write_ios" : 0, + "read_sectors" : 103061600, + "write_sectors" : 0, + "read_merges" : 4719, + "write_merges" : 0, + "read_ticks" : 3116334, + "write_ticks" : 0, + "in_queue" : 3116334, + "util" : 99.695647 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdf.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdf.json new file mode 100644 index 0000000..8e3f500 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q16_vdf.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674969, + "timestamp_ms" : 1793674969557, + "time" : "Tue Nov 3 03:02:49 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdf", + "groupid" : 0, + "job_start" : 1793674944491, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 52974059520, + "io_kbytes" : 51732480, + "bw_bytes" : 2116422673, + "bw" : 2066819, + "iops" : 504.594487, + "runtime" : 25030, + "total_ios" : 12630, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 71809, + "max" : 12280263, + "mean" : 1858796.037609, + "stddev" : 1469617.000836, + "N" : 12630 + }, + "clat_ns" : { + "min" : 8787353, + "max" : 57511020, + "mean" : 29827128.970309, + "stddev" : 4046082.953878, + "N" : 12630, + "percentile" : { + "1.000000" : 15007744, + "5.000000" : 19529728, + "10.000000" : 25821184, + "20.000000" : 28966912, + "30.000000" : 29491200, + "40.000000" : 30277632, + "50.000000" : 30539776, + "60.000000" : 31064064, + "70.000000" : 31588352, + "80.000000" : 32112640, + "90.000000" : 33161216, + "95.000000" : 33816576, + "99.000000" : 36438016, + "99.500000" : 37486592, + "99.900000" : 40632320, + "99.950000" : 44302336, + "99.990000" : 55312384 + } + }, + "lat_ns" : { + "min" : 9498918, + "max" : 59595721, + "mean" : 31685925.007918, + "stddev" : 4363884.648939, + "N" : 12630 + }, + "bw_min" : 1966080, + "bw_max" : 3342336, + "bw_agg" : 100.000000, + "bw_mean" : 2070569.795918, + "bw_dev" : 298242.670532, + "bw_samples" : 49, + "iops_min" : 480, + "iops_max" : 816, + "iops_mean" : 505.510204, + "iops_stddev" : 72.813152, + "iops_samples" : 49 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 25029, + "usr_cpu" : 0.843022, + "sys_cpu" : 10.523792, + "ctx" : 13613, + "majf" : 0, + "minf" : 16396, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.881235, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.992074, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.023753, + "20" : 5.605701, + "50" : 94.338876, + "100" : 0.031671, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdf", + "read_ios" : 122567, + "write_ios" : 0, + "read_sectors" : 102952992, + "write_sectors" : 0, + "read_merges" : 3926, + "write_merges" : 0, + "read_ticks" : 3111917, + "write_ticks" : 0, + "in_queue" : 3111917, + "util" : 99.711642 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q1_vdc.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q1_vdc.json new file mode 100644 index 0000000..b266518 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q1_vdc.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675071, + "timestamp_ms" : 1793675071180, + "time" : "Tue Nov 3 03:04:31 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "1", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675046139, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 25820135424, + "io_kbytes" : 25214976, + "bw_bytes" : 1032681495, + "bw" : 1008478, + "iops" : 246.210455, + "runtime" : 25003, + "total_ios" : 6156, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 70783, + "max" : 1475196, + "mean" : 134311.565627, + "stddev" : 23290.873706, + "N" : 6156 + }, + "clat_ns" : { + "min" : 2223225, + "max" : 7985101, + "mean" : 3921628.747563, + "stddev" : 605506.598269, + "N" : 6156, + "percentile" : { + "1.000000" : 2670592, + "5.000000" : 2965504, + "10.000000" : 3162112, + "20.000000" : 3424256, + "30.000000" : 3620864, + "40.000000" : 3751936, + "50.000000" : 3883008, + "60.000000" : 4046848, + "70.000000" : 4177920, + "80.000000" : 4358144, + "90.000000" : 4685824, + "95.000000" : 4947968, + "99.000000" : 5537792, + "99.500000" : 5799936, + "99.900000" : 6586368, + "99.950000" : 7438336, + "99.990000" : 7962624 + } + }, + "lat_ns" : { + "min" : 2358356, + "max" : 8116321, + "mean" : 4055940.313190, + "stddev" : 605198.054589, + "N" : 6156 + }, + "bw_min" : 925696, + "bw_max" : 1212416, + "bw_agg" : 100.000000, + "bw_mean" : 1010290.938776, + "bw_dev" : 64663.801532, + "bw_samples" : 49, + "iops_min" : 226, + "iops_max" : 296, + "iops_mean" : 246.653061, + "iops_stddev" : 15.787061, + "iops_samples" : 49 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 25002, + "usr_cpu" : 0.439965, + "sys_cpu" : 4.023678, + "ctx" : 6156, + "majf" : 0, + "minf" : 1036, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 57.586095, + "10" : 42.413905, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 1, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 67398, + "write_ios" : 0, + "read_sectors" : 50192416, + "write_sectors" : 0, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 209682, + "write_ticks" : 0, + "in_queue" : 209682, + "util" : 96.912295 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q64_all.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q64_all.json new file mode 100644 index 0000000..5de859c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/read_4M_q64_all.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675020, + "timestamp_ms" : 1793675020419, + "time" : "Tue Nov 3 03:03:40 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "64", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793674995261, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 151573757952, + "io_kbytes" : 148021248, + "bw_bytes" : 6041924421, + "bw" : 5900316, + "iops" : 1440.507036, + "runtime" : 25087, + "total_ios" : 36138, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 51770, + "max" : 105432708, + "mean" : 2757817.817090, + "stddev" : 6186038.446234, + "N" : 36138 + }, + "clat_ns" : { + "min" : 60001367, + "max" : 299307963, + "mean" : 174593356.803337, + "stddev" : 27501889.290907, + "N" : 36138, + "percentile" : { + "1.000000" : 105381888, + "5.000000" : 131596288, + "10.000000" : 141557760, + "20.000000" : 152043520, + "30.000000" : 160432128, + "40.000000" : 166723584, + "50.000000" : 173015040, + "60.000000" : 179306496, + "70.000000" : 187695104, + "80.000000" : 196083712, + "90.000000" : 208666624, + "95.000000" : 221249536, + "99.000000" : 244318208, + "99.500000" : 254803968, + "99.900000" : 274726912, + "99.950000" : 283115520, + "99.990000" : 291504128 + } + }, + "lat_ns" : { + "min" : 69328072, + "max" : 300016095, + "mean" : 177351174.620428, + "stddev" : 27855835.324694, + "N" : 36138 + }, + "bw_min" : 4046848, + "bw_max" : 7077888, + "bw_agg" : 99.648242, + "bw_mean" : 5879562.240000, + "bw_dev" : 124223.769917, + "bw_samples" : 200, + "iops_min" : 988, + "iops_max" : 1728, + "iops_mean" : 1435.440000, + "iops_stddev" : 30.328069, + "iops_samples" : 200 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 100342, + "usr_cpu" : 0.213271, + "sys_cpu" : 4.237508, + "ctx" : 16609, + "majf" : 0, + "minf" : 262194, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.177099, + "32" : 0.354198, + ">=64" : 99.302673 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.988855, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.100000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.653052, + "250" : 98.633018, + "500" : 0.713930, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 64, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 39323, + "write_ios" : 0, + "read_sectors" : 74365440, + "write_sectors" : 0, + "read_merges" : 992, + "write_merges" : 0, + "read_ticks" : 3149645, + "write_ticks" : 0, + "in_queue" : 3149645, + "util" : 99.663596 + }, + { + "name" : "vdd", + "read_ios" : 39349, + "write_ios" : 0, + "read_sectors" : 73671264, + "write_sectors" : 0, + "read_merges" : 1129, + "write_merges" : 0, + "read_ticks" : 3167158, + "write_ticks" : 0, + "in_queue" : 3167158, + "util" : 99.671580 + }, + { + "name" : "vde", + "read_ios" : 40303, + "write_ios" : 0, + "read_sectors" : 72746632, + "write_sectors" : 0, + "read_merges" : 1109, + "write_merges" : 0, + "read_ticks" : 3250516, + "write_ticks" : 0, + "in_queue" : 3250516, + "util" : 99.687550 + }, + { + "name" : "vdf", + "read_ios" : 39079, + "write_ios" : 0, + "read_sectors" : 72923248, + "write_sectors" : 0, + "read_merges" : 1113, + "write_merges" : 0, + "read_ticks" : 3223776, + "write_ticks" : 0, + "in_queue" : 3223776, + "util" : 99.691543 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_all.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_all.json new file mode 100644 index 0000000..d61787b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_all.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675096, + "timestamp_ms" : 1793675096667, + "time" : "Tue Nov 3 03:04:56 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675071518, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 49828331520, + "io_kbytes" : 48660480, + "bw_bytes" : 1985746284, + "bw" : 1939205, + "iops" : 473.438808, + "runtime" : 25093, + "total_ios" : 11880, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 148776, + "max" : 804821, + "mean" : 425194.755556, + "stddev" : 104008.291075, + "N" : 11880 + }, + "clat_ns" : { + "min" : 24969661, + "max" : 217583935, + "mean" : 134677155.849663, + "stddev" : 20559469.341796, + "N" : 11880, + "percentile" : { + "1.000000" : 86507520, + "5.000000" : 102236160, + "10.000000" : 108527616, + "20.000000" : 116916224, + "30.000000" : 124256256, + "40.000000" : 129499136, + "50.000000" : 135266304, + "60.000000" : 139460608, + "70.000000" : 145752064, + "80.000000" : 152043520, + "90.000000" : 160432128, + "95.000000" : 166723584, + "99.000000" : 183500800, + "99.500000" : 191889408, + "99.900000" : 206569472, + "99.950000" : 210763776, + "99.990000" : 217055232 + } + }, + "lat_ns" : { + "min" : 25450372, + "max" : 218143713, + "mean" : 135102350.605219, + "stddev" : 20593175.885752, + "N" : 11880 + }, + "bw_min" : 1499136, + "bw_max" : 2375680, + "bw_agg" : 99.866009, + "bw_mean" : 1936607.500000, + "bw_dev" : 49890.274708, + "bw_samples" : 200, + "iops_min" : 366, + "iops_max" : 580, + "iops_mean" : 472.800000, + "iops_stddev" : 12.180782, + "iops_samples" : 200 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 100351, + "usr_cpu" : 4.208229, + "sys_cpu" : 1.694054, + "ctx" : 11723, + "majf" : 0, + "minf" : 54, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.134680, + "8" : 0.269360, + "16" : 99.494949, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.966171, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.050505, + "100" : 4.292929, + "250" : 95.656566, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 13210, + "read_sectors" : 2096, + "write_sectors" : 24387584, + "read_merges" : 0, + "write_merges" : 1496, + "read_ticks" : 76, + "write_ticks" : 1722127, + "in_queue" : 1722202, + "util" : 99.743641 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 13967, + "read_sectors" : 2112, + "write_sectors" : 24098752, + "read_merges" : 0, + "write_merges" : 1292, + "read_ticks" : 87, + "write_ticks" : 1839032, + "in_queue" : 1839119, + "util" : 99.799704 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 15415, + "read_sectors" : 2112, + "write_sectors" : 23786496, + "read_merges" : 0, + "write_merges" : 728, + "read_ticks" : 80, + "write_ticks" : 2053946, + "in_queue" : 2054026, + "util" : 99.815698 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 13124, + "read_sectors" : 2112, + "write_sectors" : 23896064, + "read_merges" : 0, + "write_merges" : 1647, + "read_ticks" : 77, + "write_ticks" : 1744682, + "in_queue" : 1744759, + "util" : 99.791650 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdc.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdc.json new file mode 100644 index 0000000..1e6d262 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdc.json @@ -0,0 +1,276 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674753, + "timestamp_ms" : 1793674753903, + "time" : "Tue Nov 3 02:59:13 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793674716007, + "error" : 0, + "eta" : 0, + "elapsed" : 39, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 51539607552, + "io_kbytes" : 50331648, + "bw_bytes" : 1361752471, + "bw" : 1329836, + "iops" : 324.667089, + "runtime" : 37848, + "total_ios" : 12288, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 108062, + "max" : 1184618, + "mean" : 263867.072021, + "stddev" : 68083.047658, + "N" : 12288 + }, + "clat_ns" : { + "min" : 11329187, + "max" : 107627899, + "mean" : 49004781.557698, + "stddev" : 6124771.456461, + "N" : 12288, + "percentile" : { + "1.000000" : 40108032, + "5.000000" : 42205184, + "10.000000" : 43253760, + "20.000000" : 44826624, + "30.000000" : 45875200, + "40.000000" : 46923776, + "50.000000" : 47972352, + "60.000000" : 49020928, + "70.000000" : 50069504, + "80.000000" : 52690944, + "90.000000" : 56360960, + "95.000000" : 60555264, + "99.000000" : 70778880, + "99.500000" : 73924608, + "99.900000" : 92798976, + "99.950000" : 102236160, + "99.990000" : 107479040 + } + }, + "lat_ns" : { + "min" : 11534390, + "max" : 107862482, + "mean" : 49268648.629720, + "stddev" : 6145866.683851, + "N" : 12288 + }, + "bw_min" : 1024000, + "bw_max" : 1564672, + "bw_agg" : 99.981020, + "bw_mean" : 1329584.160000, + "bw_dev" : 128214.527086, + "bw_samples" : 75, + "iops_min" : 250, + "iops_max" : 382, + "iops_mean" : 324.600000, + "iops_stddev" : 31.307973, + "iops_samples" : 75 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 37847, + "usr_cpu" : 6.978096, + "sys_cpu" : 3.781013, + "ctx" : 11793, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.877930, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.991853, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.010000, + "50" : 68.668620, + "100" : 31.266276, + "250" : 0.056966, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48, + "write_ios" : 51842, + "read_sectors" : 2088, + "write_sectors" : 99931136, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 63, + "write_ticks" : 2499079, + "in_queue" : 2499143, + "util" : 99.885951 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdd.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdd.json new file mode 100644 index 0000000..a220e6d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdd.json @@ -0,0 +1,276 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674791, + "timestamp_ms" : 1793674791629, + "time" : "Tue Nov 3 02:59:51 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G" + }, + "jobs" : [ + { + "jobname" : "vdd", + "groupid" : 0, + "job_start" : 1793674754232, + "error" : 0, + "eta" : 0, + "elapsed" : 38, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 51539607552, + "io_kbytes" : 50331648, + "bw_bytes" : 1379983066, + "bw" : 1347639, + "iops" : 329.013602, + "runtime" : 37348, + "total_ios" : 12288, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 135482, + "max" : 17615371, + "mean" : 2984999.972331, + "stddev" : 1716046.096013, + "N" : 12288 + }, + "clat_ns" : { + "min" : 20410856, + "max" : 73723811, + "mean" : 45629681.016276, + "stddev" : 4836488.931750, + "N" : 12288, + "percentile" : { + "1.000000" : 35389440, + "5.000000" : 39583744, + "10.000000" : 41156608, + "20.000000" : 42205184, + "30.000000" : 43253760, + "40.000000" : 43778048, + "50.000000" : 44826624, + "60.000000" : 45875200, + "70.000000" : 46923776, + "80.000000" : 49020928, + "90.000000" : 51642368, + "95.000000" : 54788096, + "99.000000" : 61603840, + "99.500000" : 64225280, + "99.900000" : 68681728, + "99.950000" : 70778880, + "99.990000" : 71827456 + } + }, + "lat_ns" : { + "min" : 20749134, + "max" : 76698593, + "mean" : 48614680.988607, + "stddev" : 4938396.090324, + "N" : 12288 + }, + "bw_min" : 1056768, + "bw_max" : 1499136, + "bw_agg" : 100.000000, + "bw_mean" : 1348469.621622, + "bw_dev" : 95301.331090, + "bw_samples" : 74, + "iops_min" : 258, + "iops_max" : 366, + "iops_mean" : 329.216216, + "iops_stddev" : 23.266927, + "iops_samples" : 74 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 37347, + "usr_cpu" : 14.788336, + "sys_cpu" : 6.664525, + "ctx" : 13688, + "majf" : 0, + "minf" : 11, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.877930, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.991853, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 84.497070, + "100" : 15.502930, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 137343, + "read_sectors" : 2112, + "write_sectors" : 100008112, + "read_merges" : 0, + "write_merges" : 763, + "read_ticks" : 47, + "write_ticks" : 4697878, + "in_queue" : 4697926, + "util" : 99.846787 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vde.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vde.json new file mode 100644 index 0000000..33a225f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vde.json @@ -0,0 +1,276 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674829, + "timestamp_ms" : 1793674829538, + "time" : "Tue Nov 3 03:00:29 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G" + }, + "jobs" : [ + { + "jobname" : "vde", + "groupid" : 0, + "job_start" : 1793674791954, + "error" : 0, + "eta" : 0, + "elapsed" : 38, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 51539607552, + "io_kbytes" : 50331648, + "bw_bytes" : 1373071386, + "bw" : 1340890, + "iops" : 327.365729, + "runtime" : 37536, + "total_ios" : 12288, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 172319, + "max" : 21862601, + "mean" : 3012112.585205, + "stddev" : 2034657.524892, + "N" : 12288 + }, + "clat_ns" : { + "min" : 25405091, + "max" : 94495973, + "mean" : 45845515.809163, + "stddev" : 5980803.052388, + "N" : 12288, + "percentile" : { + "1.000000" : 32636928, + "5.000000" : 38535168, + "10.000000" : 40632320, + "20.000000" : 42205184, + "30.000000" : 43253760, + "40.000000" : 43778048, + "50.000000" : 44826624, + "60.000000" : 45875200, + "70.000000" : 46923776, + "80.000000" : 48496640, + "90.000000" : 52690944, + "95.000000" : 58458112, + "99.000000" : 66322432, + "99.500000" : 68681728, + "99.900000" : 78118912, + "99.950000" : 82313216, + "99.990000" : 88604672 + } + }, + "lat_ns" : { + "min" : 25931184, + "max" : 98282817, + "mean" : 48857628.394368, + "stddev" : 6237857.727743, + "N" : 12288 + }, + "bw_min" : 999424, + "bw_max" : 1572864, + "bw_agg" : 100.000000, + "bw_mean" : 1345563.500000, + "bw_dev" : 117152.128388, + "bw_samples" : 74, + "iops_min" : 244, + "iops_max" : 384, + "iops_mean" : 328.500000, + "iops_stddev" : 28.619971, + "iops_samples" : 74 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 37535, + "usr_cpu" : 12.649527, + "sys_cpu" : 6.378047, + "ctx" : 14008, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.877930, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.991853, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 85.245768, + "100" : 14.754232, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vde", + "read_ios" : 50, + "write_ios" : 145384, + "read_sectors" : 2104, + "write_sectors" : 100292640, + "read_merges" : 0, + "write_merges" : 0, + "read_ticks" : 80, + "write_ticks" : 4715922, + "in_queue" : 4716003, + "util" : 99.903877 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdf.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdf.json new file mode 100644 index 0000000..8937644 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q16_vdf.json @@ -0,0 +1,276 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793674868, + "timestamp_ms" : 1793674868119, + "time" : "Tue Nov 3 03:01:08 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G" + }, + "jobs" : [ + { + "jobname" : "vdf", + "groupid" : 0, + "job_start" : 1793674829853, + "error" : 0, + "eta" : 0, + "elapsed" : 39, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 51539607552, + "io_kbytes" : 50331648, + "bw_bytes" : 1348463084, + "bw" : 1316858, + "iops" : 321.498653, + "runtime" : 38221, + "total_ios" : 12288, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 146457, + "max" : 23097829, + "mean" : 3064459.697754, + "stddev" : 2010176.169336, + "N" : 12288 + }, + "clat_ns" : { + "min" : 26540877, + "max" : 76978400, + "mean" : 46685948.657552, + "stddev" : 6469913.843433, + "N" : 12288, + "percentile" : { + "1.000000" : 34865152, + "5.000000" : 39583744, + "10.000000" : 40632320, + "20.000000" : 42205184, + "30.000000" : 43253760, + "40.000000" : 43778048, + "50.000000" : 44826624, + "60.000000" : 45875200, + "70.000000" : 47972352, + "80.000000" : 51118080, + "90.000000" : 56360960, + "95.000000" : 60030976, + "99.000000" : 67633152, + "99.500000" : 69730304, + "99.900000" : 72876032, + "99.950000" : 73924608, + "99.990000" : 76021760 + } + }, + "lat_ns" : { + "min" : 26979851, + "max" : 80498896, + "mean" : 49750408.355306, + "stddev" : 6721634.447344, + "N" : 12288 + }, + "bw_min" : 892928, + "bw_max" : 1540096, + "bw_agg" : 100.000000, + "bw_mean" : 1317911.986842, + "bw_dev" : 141738.655271, + "bw_samples" : 76, + "iops_min" : 218, + "iops_max" : 376, + "iops_mean" : 321.750000, + "iops_stddev" : 34.611800, + "iops_samples" : 76 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 38220, + "usr_cpu" : 8.958660, + "sys_cpu" : 5.957614, + "ctx" : 13876, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.877930, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.991853, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 77.058919, + "100" : 22.941081, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 132477, + "read_sectors" : 2112, + "write_sectors" : 100372488, + "read_merges" : 0, + "write_merges" : 767, + "read_ticks" : 106, + "write_ticks" : 4809537, + "in_queue" : 4809644, + "util" : 99.942414 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q64_all.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q64_all.json new file mode 100644 index 0000000..393b6cc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline/write_4M_q64_all.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675122, + "timestamp_ms" : 1793675122361, + "time" : "Tue Nov 3 03:05:22 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "64", + "size" : "48G", + "runtime" : "25" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675097135, + "error" : 0, + "eta" : 0, + "elapsed" : 26, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 50100961280, + "io_kbytes" : 48926720, + "bw_bytes" : 1991294168, + "bw" : 1944623, + "iops" : 474.761526, + "runtime" : 25160, + "total_ios" : 11945, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 186105, + "max" : 298495546, + "mean" : 8366358.771704, + "stddev" : 10958269.347992, + "N" : 11945 + }, + "clat_ns" : { + "min" : 126746604, + "max" : 815459792, + "mean" : 528278510.324069, + "stddev" : 54498657.967473, + "N" : 11945, + "percentile" : { + "1.000000" : 316669952, + "5.000000" : 455081984, + "10.000000" : 480247808, + "20.000000" : 497025024, + "30.000000" : 509607936, + "40.000000" : 522190848, + "50.000000" : 530579456, + "60.000000" : 541065216, + "70.000000" : 549453824, + "80.000000" : 566231040, + "90.000000" : 583008256, + "95.000000" : 599785472, + "99.000000" : 641728512, + "99.500000" : 692060160, + "99.900000" : 792723456, + "99.950000" : 809500672, + "99.990000" : 817889280 + } + }, + "lat_ns" : { + "min" : 148163930, + "max" : 835882302, + "mean" : 536644869.095773, + "stddev" : 54927006.013936, + "N" : 11945 + }, + "bw_min" : 729957, + "bw_max" : 2457600, + "bw_agg" : 98.506538, + "bw_mean" : 1915581.900000, + "bw_dev" : 65213.487154, + "bw_samples" : 200, + "iops_min" : 178, + "iops_max" : 600, + "iops_mean" : 467.480000, + "iops_stddev" : 15.948346, + "iops_samples" : 200 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 100590, + "usr_cpu" : 3.896014, + "sys_cpu" : 1.364947, + "ctx" : 6012, + "majf" : 0, + "minf" : 53, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.133947, + "8" : 0.267895, + "16" : 0.535789, + "32" : 1.071578, + ">=64" : 97.890331 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.965803, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.100000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.435329, + "500" : 21.230640, + "750" : 78.124738, + "1000" : 0.209293, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 64, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48, + "write_ios" : 12528, + "read_sectors" : 2088, + "write_sectors" : 24433664, + "read_merges" : 0, + "write_merges" : 282, + "read_ticks" : 82, + "write_ticks" : 3100997, + "in_queue" : 3101078, + "util" : 99.321563 + }, + { + "name" : "vdd", + "read_ios" : 50, + "write_ios" : 12419, + "read_sectors" : 2104, + "write_sectors" : 24303104, + "read_merges" : 0, + "write_merges" : 322, + "read_ticks" : 78, + "write_ticks" : 3185649, + "in_queue" : 3185727, + "util" : 99.353252 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 12360, + "read_sectors" : 2112, + "write_sectors" : 24104936, + "read_merges" : 0, + "write_merges" : 368, + "read_ticks" : 82, + "write_ticks" : 3142759, + "in_queue" : 3142841, + "util" : 99.361060 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 12244, + "read_sectors" : 2112, + "write_sectors" : 23969792, + "read_merges" : 0, + "write_merges" : 322, + "read_ticks" : 84, + "write_ticks" : 3101883, + "in_queue" : 3101968, + "util" : 99.400722 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/memory.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/memory.txt new file mode 100644 index 0000000..332384e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/memory.txt @@ -0,0 +1,24 @@ +crc32 threads 1: 25488 MB/s +memcpy threads 1: 14040 MB/s +tmpfs_read threads 1: 11731 MB/s +tmpfs_create threads 1: 2806 MB/s +crc32 threads 2: 48287 MB/s +memcpy threads 2: 32880 MB/s +tmpfs_read threads 2: 21640 MB/s +tmpfs_create threads 2: 6000 MB/s +crc32 threads 4: 107506 MB/s +memcpy threads 4: 58450 MB/s +tmpfs_read threads 4: 38337 MB/s +tmpfs_create threads 4: 10812 MB/s +crc32 threads 8: 167649 MB/s +memcpy threads 8: 108661 MB/s +tmpfs_read threads 8: 66569 MB/s +tmpfs_create threads 8: 23753 MB/s +crc32 threads 12: 264015 MB/s +memcpy threads 12: 111143 MB/s +tmpfs_read threads 12: 99091 MB/s +tmpfs_create threads 12: 30648 MB/s +crc32 threads 24: 457565 MB/s +memcpy threads 24: 130364 MB/s +tmpfs_read threads 24: 96767 MB/s +tmpfs_create threads 24: 27795 MB/s diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_1.json new file mode 100644 index 0000000..a884069 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675259, + "timestamp_ms" : 1793675259537, + "time" : "Tue Nov 3 03:07:39 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675239464, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 43209719808, + "io_kbytes" : 42196992, + "bw_bytes" : 2157357821, + "bw" : 2106794, + "iops" : 514.354186, + "runtime" : 20029, + "total_ios" : 10302, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 62263, + "max" : 8331851, + "mean" : 964300.782955, + "stddev" : 1233540.545152, + "N" : 10302 + }, + "clat_ns" : { + "min" : 4941905, + "max" : 57337991, + "mean" : 30120299.504562, + "stddev" : 5295782.870075, + "N" : 10302, + "percentile" : { + "1.000000" : 9633792, + "5.000000" : 14221312, + "10.000000" : 28704768, + "20.000000" : 30015488, + "30.000000" : 30539776, + "40.000000" : 31064064, + "50.000000" : 31588352, + "60.000000" : 31850496, + "70.000000" : 32374784, + "80.000000" : 32636928, + "90.000000" : 33161216, + "95.000000" : 33816576, + "99.000000" : 34340864, + "99.500000" : 34865152, + "99.900000" : 41156608, + "99.950000" : 49020928, + "99.990000" : 53215232 + } + }, + "lat_ns" : { + "min" : 5040634, + "max" : 60086102, + "mean" : 31084600.287517, + "stddev" : 5467043.063963, + "N" : 10302 + }, + "bw_min" : 1933312, + "bw_max" : 4554752, + "bw_agg" : 99.999158, + "bw_mean" : 2106777.600000, + "bw_dev" : 458582.755594, + "bw_samples" : 40, + "iops_min" : 472, + "iops_max" : 1112, + "iops_mean" : 514.350000, + "iops_stddev" : 111.958681, + "iops_samples" : 40 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20028, + "usr_cpu" : 0.714000, + "sys_cpu" : 8.837627, + "ctx" : 11308, + "majf" : 0, + "minf" : 16397, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.854397, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990280, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 1.271598, + "20" : 6.688022, + "50" : 91.991846, + "100" : 0.048534, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 83827, + "write_ios" : 0, + "read_sectors" : 83847272, + "write_sectors" : 0, + "read_merges" : 4482, + "write_merges" : 0, + "read_ticks" : 2452817, + "write_ticks" : 0, + "in_queue" : 2452817, + "util" : 99.594493 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_2.json new file mode 100644 index 0000000..115d1f1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_2.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675422, + "timestamp_ms" : 1793675422978, + "time" : "Tue Nov 3 03:10:22 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675402903, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 43524292608, + "io_kbytes" : 42504192, + "bw_bytes" : 2172629791, + "bw" : 2121708, + "iops" : 517.995308, + "runtime" : 20033, + "total_ios" : 10377, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 56564, + "max" : 1690008, + "mean" : 125729.189361, + "stddev" : 59301.404781, + "N" : 10377 + }, + "clat_ns" : { + "min" : 7764636, + "max" : 61426791, + "mean" : 30736207.541968, + "stddev" : 5301777.235700, + "N" : 10377, + "percentile" : { + "1.000000" : 11075584, + "5.000000" : 15007744, + "10.000000" : 29229056, + "20.000000" : 30801920, + "30.000000" : 31326208, + "40.000000" : 31850496, + "50.000000" : 32112640, + "60.000000" : 32636928, + "70.000000" : 32899072, + "80.000000" : 33161216, + "90.000000" : 33816576, + "95.000000" : 34340864, + "99.000000" : 35389440, + "99.500000" : 35913728, + "99.900000" : 43253760, + "99.950000" : 51118080, + "99.990000" : 57933824 + } + }, + "lat_ns" : { + "min" : 7859536, + "max" : 61555683, + "mean" : 30861936.731329, + "stddev" : 5301806.092857, + "N" : 10377 + }, + "bw_min" : 1949696, + "bw_max" : 4349952, + "bw_agg" : 100.000000, + "bw_mean" : 2122137.600000, + "bw_dev" : 449433.672087, + "bw_samples" : 40, + "iops_min" : 476, + "iops_max" : 1062, + "iops_mean" : 518.100000, + "iops_stddev" : 109.725018, + "iops_samples" : 40 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20032, + "usr_cpu" : 0.958466, + "sys_cpu" : 8.211861, + "ctx" : 9902, + "majf" : 0, + "minf" : 16396, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.855450, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990350, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.597475, + "20" : 7.882818, + "50" : 91.461887, + "100" : 0.057820, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 72204, + "write_ios" : 0, + "read_sectors" : 84451384, + "write_sectors" : 0, + "read_merges" : 5163, + "write_merges" : 0, + "read_ticks" : 2106219, + "write_ticks" : 0, + "in_queue" : 2106219, + "util" : 99.594473 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_3.json new file mode 100644 index 0000000..cd7479f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r1_3.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675586, + "timestamp_ms" : 1793675586381, + "time" : "Tue Nov 3 03:13:06 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675566309, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 43704647680, + "io_kbytes" : 42680320, + "bw_bytes" : 2181741597, + "bw" : 2130607, + "iops" : 520.167732, + "runtime" : 20032, + "total_ios" : 10420, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 60778, + "max" : 1527566, + "mean" : 122730.790307, + "stddev" : 53885.267218, + "N" : 10420 + }, + "clat_ns" : { + "min" : 6119740, + "max" : 59806593, + "mean" : 30612121.116315, + "stddev" : 5509623.253628, + "N" : 10420, + "percentile" : { + "1.000000" : 9895936, + "5.000000" : 13434880, + "10.000000" : 29491200, + "20.000000" : 30801920, + "30.000000" : 31326208, + "40.000000" : 31850496, + "50.000000" : 32112640, + "60.000000" : 32374784, + "70.000000" : 32636928, + "80.000000" : 33161216, + "90.000000" : 33816576, + "95.000000" : 33816576, + "99.000000" : 35389440, + "99.500000" : 35913728, + "99.900000" : 43253760, + "99.950000" : 49545216, + "99.990000" : 58982400 + } + }, + "lat_ns" : { + "min" : 6273108, + "max" : 59897952, + "mean" : 30734851.906622, + "stddev" : 5508251.115957, + "N" : 10420 + }, + "bw_min" : 1957888, + "bw_max" : 4816896, + "bw_agg" : 100.000000, + "bw_mean" : 2130944.000000, + "bw_dev" : 478255.478453, + "bw_samples" : 40, + "iops_min" : 478, + "iops_max" : 1176, + "iops_mean" : 520.250000, + "iops_stddev" : 116.761591, + "iops_samples" : 40 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20031, + "usr_cpu" : 0.748839, + "sys_cpu" : 8.401977, + "ctx" : 9962, + "majf" : 0, + "minf" : 16394, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.856046, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990390, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 1.017274, + "20" : 6.861804, + "50" : 92.072937, + "100" : 0.047985, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 65384, + "write_ios" : 0, + "read_sectors" : 84797464, + "write_sectors" : 0, + "read_merges" : 6478, + "write_merges" : 0, + "read_ticks" : 1904102, + "write_ticks" : 0, + "in_queue" : 1904102, + "util" : 99.599439 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_1.json new file mode 100644 index 0000000..ec89447 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_1.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675279, + "timestamp_ms" : 1793675279917, + "time" : "Tue Nov 3 03:07:59 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675259841, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 86201335808, + "io_kbytes" : 84180992, + "bw_bytes" : 4303396525, + "bw" : 4202535, + "iops" : 1026.009685, + "runtime" : 20031, + "total_ios" : 20552, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 53633, + "max" : 1862155, + "mean" : 108943.675993, + "stddev" : 59859.264050, + "N" : 20552 + }, + "clat_ns" : { + "min" : 7659060, + "max" : 60262565, + "mean" : 31052262.464626, + "stddev" : 4069605.619310, + "N" : 20552, + "percentile" : { + "1.000000" : 15007744, + "5.000000" : 21102592, + "10.000000" : 27656192, + "20.000000" : 30277632, + "30.000000" : 31064064, + "40.000000" : 31588352, + "50.000000" : 31850496, + "60.000000" : 32374784, + "70.000000" : 32636928, + "80.000000" : 33161216, + "90.000000" : 33816576, + "95.000000" : 34865152, + "99.000000" : 36962304, + "99.500000" : 38535168, + "99.900000" : 44826624, + "99.950000" : 51118080, + "99.990000" : 58458112 + } + }, + "lat_ns" : { + "min" : 9027623, + "max" : 60390026, + "mean" : 31161206.140619, + "stddev" : 4063764.195677, + "N" : 20552 + }, + "bw_min" : 3891200, + "bw_max" : 6807552, + "bw_agg" : 100.000000, + "bw_mean" : 4202905.600000, + "bw_dev" : 277452.591959, + "bw_samples" : 80, + "iops_min" : 950, + "iops_max" : 1662, + "iops_mean" : 1026.100000, + "iops_stddev" : 67.737449, + "iops_samples" : 80 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40058, + "usr_cpu" : 0.723950, + "sys_cpu" : 7.349343, + "ctx" : 19186, + "majf" : 0, + "minf" : 32793, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.854029, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990255, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.029194, + "20" : 4.267225, + "50" : 95.650058, + "100" : 0.053523, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 59082, + "write_ios" : 0, + "read_sectors" : 82370672, + "write_sectors" : 0, + "read_merges" : 5663, + "write_merges" : 0, + "read_ticks" : 1764722, + "write_ticks" : 0, + "in_queue" : 1764721, + "util" : 99.594453 + }, + { + "name" : "vdd", + "read_ios" : 63458, + "write_ios" : 0, + "read_sectors" : 84871136, + "write_sectors" : 0, + "read_merges" : 7137, + "write_merges" : 0, + "read_ticks" : 1830655, + "write_ticks" : 0, + "in_queue" : 1830655, + "util" : 99.604426 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_2.json new file mode 100644 index 0000000..e2641b5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_2.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675443, + "timestamp_ms" : 1793675443380, + "time" : "Tue Nov 3 03:10:43 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675423281, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 86897590272, + "io_kbytes" : 84860928, + "bw_bytes" : 4338155372, + "bw" : 4236479, + "iops" : 1034.296840, + "runtime" : 20031, + "total_ios" : 20718, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 57036, + "max" : 1599512, + "mean" : 96622.721740, + "stddev" : 48861.688200, + "N" : 20718 + }, + "clat_ns" : { + "min" : 7486028, + "max" : 60988110, + "mean" : 30820245.227773, + "stddev" : 4135872.606483, + "N" : 20718, + "percentile" : { + "1.000000" : 13697024, + "5.000000" : 19791872, + "10.000000" : 28966912, + "20.000000" : 30277632, + "30.000000" : 31064064, + "40.000000" : 31326208, + "50.000000" : 31850496, + "60.000000" : 32112640, + "70.000000" : 32374784, + "80.000000" : 32899072, + "90.000000" : 33423360, + "95.000000" : 33816576, + "99.000000" : 35389440, + "99.500000" : 36438016, + "99.900000" : 41680896, + "99.950000" : 50069504, + "99.990000" : 59506688 + } + }, + "lat_ns" : { + "min" : 8769067, + "max" : 61065361, + "mean" : 30916867.949513, + "stddev" : 4130271.924307, + "N" : 20718 + }, + "bw_min" : 3923968, + "bw_max" : 7151616, + "bw_agg" : 100.000000, + "bw_mean" : 4236902.400000, + "bw_dev" : 296338.692513, + "bw_samples" : 80, + "iops_min" : 958, + "iops_max" : 1746, + "iops_mean" : 1034.400000, + "iops_stddev" : 72.348314, + "iops_samples" : 80 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40060, + "usr_cpu" : 0.738892, + "sys_cpu" : 6.737394, + "ctx" : 19780, + "majf" : 0, + "minf" : 32794, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.855198, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990333, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.033787, + "20" : 5.169418, + "50" : 94.738874, + "100" : 0.057921, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 47478, + "write_ios" : 0, + "read_sectors" : 82966560, + "write_sectors" : 0, + "read_merges" : 7609, + "write_merges" : 0, + "read_ticks" : 1425565, + "write_ticks" : 0, + "in_queue" : 1425565, + "util" : 99.594432 + }, + { + "name" : "vdd", + "read_ios" : 49000, + "write_ios" : 0, + "read_sectors" : 85626952, + "write_sectors" : 0, + "read_merges" : 8507, + "write_merges" : 0, + "read_ticks" : 1421284, + "write_ticks" : 0, + "in_queue" : 1421284, + "util" : 99.604407 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_3.json new file mode 100644 index 0000000..aed3653 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2_3.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675606, + "timestamp_ms" : 1793675606747, + "time" : "Tue Nov 3 03:13:26 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675586676, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 86394273792, + "io_kbytes" : 84369408, + "bw_bytes" : 4313028495, + "bw" : 4211941, + "iops" : 1028.306126, + "runtime" : 20031, + "total_ios" : 20598, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 57213, + "max" : 1625692, + "mean" : 106596.497621, + "stddev" : 58126.181503, + "N" : 20598 + }, + "clat_ns" : { + "min" : 8722235, + "max" : 60977166, + "mean" : 30986421.839450, + "stddev" : 3911722.822971, + "N" : 20598, + "percentile" : { + "1.000000" : 15925248, + "5.000000" : 21102592, + "10.000000" : 27656192, + "20.000000" : 30277632, + "30.000000" : 30801920, + "40.000000" : 31326208, + "50.000000" : 31850496, + "60.000000" : 32374784, + "70.000000" : 32636928, + "80.000000" : 33161216, + "90.000000" : 33816576, + "95.000000" : 34865152, + "99.000000" : 36438016, + "99.500000" : 37486592, + "99.900000" : 42205184, + "99.950000" : 49545216, + "99.990000" : 58458112 + } + }, + "lat_ns" : { + "min" : 10111551, + "max" : 61099094, + "mean" : 31093018.337072, + "stddev" : 3906014.018979, + "N" : 20598 + }, + "bw_min" : 3907584, + "bw_max" : 6422528, + "bw_agg" : 100.000000, + "bw_mean" : 4212326.400000, + "bw_dev" : 256097.144910, + "bw_samples" : 80, + "iops_min" : 954, + "iops_max" : 1568, + "iops_mean" : 1028.400000, + "iops_stddev" : 62.523717, + "iops_samples" : 80 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40059, + "usr_cpu" : 0.728925, + "sys_cpu" : 7.246811, + "ctx" : 19182, + "majf" : 0, + "minf" : 32790, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.854355, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990277, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.019419, + "20" : 4.097485, + "50" : 95.834547, + "100" : 0.048548, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 55994, + "write_ios" : 0, + "read_sectors" : 82471424, + "write_sectors" : 0, + "read_merges" : 6301, + "write_merges" : 0, + "read_ticks" : 1675933, + "write_ticks" : 0, + "in_queue" : 1675933, + "util" : 99.589466 + }, + { + "name" : "vdd", + "read_ios" : 58448, + "write_ios" : 0, + "read_sectors" : 85129800, + "write_sectors" : 0, + "read_merges" : 7151, + "write_merges" : 0, + "read_ticks" : 1684836, + "write_ticks" : 0, + "in_queue" : 1684837, + "util" : 99.599439 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2b.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2b.json new file mode 100644 index 0000000..8fca18e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r2b.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675708, + "timestamp_ms" : 1793675708768, + "time" : "Tue Nov 3 03:15:08 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vde", + "groupid" : 0, + "job_start" : 1793675688695, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 87619010560, + "io_kbytes" : 85565440, + "bw_bytes" : 4373515551, + "bw" : 4271011, + "iops" : 1042.727363, + "runtime" : 20034, + "total_ios" : 20890, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 52556, + "max" : 1554047, + "mean" : 105731.594974, + "stddev" : 50395.974372, + "N" : 20890 + }, + "clat_ns" : { + "min" : 9923361, + "max" : 60057772, + "mean" : 30558870.314457, + "stddev" : 4148139.167429, + "N" : 20890, + "percentile" : { + "1.000000" : 17170432, + "5.000000" : 21102592, + "10.000000" : 23724032, + "20.000000" : 29229056, + "30.000000" : 30539776, + "40.000000" : 31064064, + "50.000000" : 31588352, + "60.000000" : 32112640, + "70.000000" : 32636928, + "80.000000" : 33161216, + "90.000000" : 34340864, + "95.000000" : 34865152, + "99.000000" : 36438016, + "99.500000" : 37486592, + "99.900000" : 44302336, + "99.950000" : 51118080, + "99.990000" : 58458112 + } + }, + "lat_ns" : { + "min" : 10055693, + "max" : 60151692, + "mean" : 30664601.909430, + "stddev" : 4147156.064582, + "N" : 20890 + }, + "bw_min" : 3932160, + "bw_max" : 6070272, + "bw_agg" : 100.000000, + "bw_mean" : 4272128.000000, + "bw_dev" : 260955.279492, + "bw_samples" : 80, + "iops_min" : 960, + "iops_max" : 1482, + "iops_mean" : 1043.000000, + "iops_stddev" : 63.709785, + "iops_samples" : 80 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40064, + "usr_cpu" : 0.678914, + "sys_cpu" : 7.260883, + "ctx" : 19019, + "majf" : 0, + "minf" : 32796, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.856391, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.990413, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 3.298229, + "50" : 96.639540, + "100" : 0.057444, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vde", + "read_ios" : 65913, + "write_ios" : 0, + "read_sectors" : 84749312, + "write_sectors" : 0, + "read_merges" : 5184, + "write_merges" : 0, + "read_ticks" : 1888996, + "write_ticks" : 0, + "in_queue" : 1888996, + "util" : 99.589466 + }, + { + "name" : "vdf", + "read_ios" : 56556, + "write_ios" : 0, + "read_sectors" : 85239888, + "write_sectors" : 0, + "read_merges" : 5861, + "write_merges" : 0, + "read_ticks" : 1615384, + "write_ticks" : 0, + "in_queue" : 1615383, + "util" : 99.599439 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_1.json new file mode 100644 index 0000000..df1c210 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_1.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675300, + "timestamp_ms" : 1793675300292, + "time" : "Tue Nov 3 03:08:20 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675280226, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 114873597952, + "io_kbytes" : 112181248, + "bw_bytes" : 5737082253, + "bw" : 5602619, + "iops" : 1367.826999, + "runtime" : 20023, + "total_ios" : 27388, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 47062, + "max" : 1616438, + "mean" : 94474.853476, + "stddev" : 60660.118007, + "N" : 27388 + }, + "clat_ns" : { + "min" : 12208954, + "max" : 74641431, + "mean" : 34969828.188878, + "stddev" : 6875572.049864, + "N" : 27388, + "percentile" : { + "1.000000" : 19529728, + "5.000000" : 23724032, + "10.000000" : 26345472, + "20.000000" : 29491200, + "30.000000" : 31588352, + "40.000000" : 33423360, + "50.000000" : 34865152, + "60.000000" : 36438016, + "70.000000" : 38010880, + "80.000000" : 40108032, + "90.000000" : 43253760, + "95.000000" : 46923776, + "99.000000" : 54263808, + "99.500000" : 56885248, + "99.900000" : 63176704, + "99.950000" : 64749568, + "99.990000" : 71827456 + } + }, + "lat_ns" : { + "min" : 12272298, + "max" : 74775945, + "mean" : 35064303.042354, + "stddev" : 6875354.784684, + "N" : 27388 + }, + "bw_min" : 4751360, + "bw_max" : 6144000, + "bw_agg" : 100.000000, + "bw_mean" : 5602970.912821, + "bw_dev" : 105447.947292, + "bw_samples" : 118, + "iops_min" : 1160, + "iops_max" : 1500, + "iops_mean" : 1367.912821, + "iops_stddev" : 25.744128, + "iops_samples" : 118 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60063, + "usr_cpu" : 0.486156, + "sys_cpu" : 5.592461, + "ctx" : 20528, + "majf" : 0, + "minf" : 49190, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.835694, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.989029, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 1.259676, + "50" : 96.228275, + "100" : 2.512049, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 45428, + "write_ios" : 0, + "read_sectors" : 74848256, + "write_sectors" : 0, + "read_merges" : 3987, + "write_merges" : 0, + "read_ticks" : 1292961, + "write_ticks" : 0, + "in_queue" : 1292961, + "util" : 99.574404 + }, + { + "name" : "vdd", + "read_ios" : 48699, + "write_ios" : 0, + "read_sectors" : 74097608, + "write_sectors" : 0, + "read_merges" : 3981, + "write_merges" : 0, + "read_ticks" : 1392031, + "write_ticks" : 0, + "in_queue" : 1392031, + "util" : 99.584377 + }, + { + "name" : "vde", + "read_ios" : 47534, + "write_ios" : 0, + "read_sectors" : 73887232, + "write_sectors" : 0, + "read_merges" : 3916, + "write_merges" : 0, + "read_ticks" : 1359420, + "write_ticks" : 0, + "in_queue" : 1359420, + "util" : 99.604327 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_2.json new file mode 100644 index 0000000..ba6f58a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_2.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675463, + "timestamp_ms" : 1793675463771, + "time" : "Tue Nov 3 03:11:03 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675443681, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 120519131136, + "io_kbytes" : 117694464, + "bw_bytes" : 6019034666, + "bw" : 5877963, + "iops" : 1435.049693, + "runtime" : 20023, + "total_ios" : 28734, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 50119, + "max" : 1727606, + "mean" : 90454.395733, + "stddev" : 59307.089881, + "N" : 28734 + }, + "clat_ns" : { + "min" : 11107402, + "max" : 66880781, + "mean" : 33333467.297557, + "stddev" : 6472119.752240, + "N" : 28734, + "percentile" : { + "1.000000" : 19005440, + "5.000000" : 22937600, + "10.000000" : 25296896, + "20.000000" : 27918336, + "30.000000" : 30015488, + "40.000000" : 31850496, + "50.000000" : 33423360, + "60.000000" : 34865152, + "70.000000" : 36438016, + "80.000000" : 38010880, + "90.000000" : 41156608, + "95.000000" : 44302336, + "99.000000" : 50593792, + "99.500000" : 53739520, + "99.900000" : 57933824, + "99.950000" : 59506688, + "99.990000" : 64749568 + } + }, + "lat_ns" : { + "min" : 11225968, + "max" : 66957491, + "mean" : 33423921.693290, + "stddev" : 6470631.714564, + "N" : 28734 + }, + "bw_min" : 5193728, + "bw_max" : 6307840, + "bw_agg" : 99.948357, + "bw_mean" : 5874928.300000, + "bw_dev" : 74396.180787, + "bw_samples" : 120, + "iops_min" : 1268, + "iops_max" : 1540, + "iops_mean" : 1434.300000, + "iops_stddev" : 18.165208, + "iops_samples" : 120 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60064, + "usr_cpu" : 0.497802, + "sys_cpu" : 5.544086, + "ctx" : 21620, + "majf" : 0, + "minf" : 49191, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.843391, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.989544, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 1.715737, + "50" : 97.073154, + "100" : 1.211109, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 46286, + "write_ios" : 0, + "read_sectors" : 78108144, + "write_sectors" : 0, + "read_merges" : 4154, + "write_merges" : 0, + "read_ticks" : 1262449, + "write_ticks" : 0, + "in_queue" : 1262450, + "util" : 99.564434 + }, + { + "name" : "vdd", + "read_ios" : 52577, + "write_ios" : 0, + "read_sectors" : 77641760, + "write_sectors" : 0, + "read_merges" : 5375, + "write_merges" : 0, + "read_ticks" : 1428251, + "write_ticks" : 0, + "in_queue" : 1428251, + "util" : 99.579411 + }, + { + "name" : "vde", + "read_ios" : 52461, + "write_ios" : 0, + "read_sectors" : 78056248, + "write_sectors" : 0, + "read_merges" : 2976, + "write_merges" : 0, + "read_ticks" : 1412109, + "write_ticks" : 0, + "in_queue" : 1412109, + "util" : 99.599359 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_3.json new file mode 100644 index 0000000..7ffb256 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r3_3.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675627, + "timestamp_ms" : 1793675627132, + "time" : "Tue Nov 3 03:13:47 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675607046, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 110079508480, + "io_kbytes" : 107499520, + "bw_bytes" : 5495183130, + "bw" : 5366389, + "iops" : 1310.153754, + "runtime" : 20032, + "total_ios" : 26245, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 51246, + "max" : 1605018, + "mean" : 95689.751076, + "stddev" : 59224.537313, + "N" : 26245 + }, + "clat_ns" : { + "min" : 12297748, + "max" : 74049686, + "mean" : 36509514.742846, + "stddev" : 6793476.464026, + "N" : 26245, + "percentile" : { + "1.000000" : 20840448, + "5.000000" : 25559040, + "10.000000" : 28442624, + "20.000000" : 31326208, + "30.000000" : 33423360, + "40.000000" : 34865152, + "50.000000" : 36438016, + "60.000000" : 37486592, + "70.000000" : 39059456, + "80.000000" : 41156608, + "90.000000" : 44826624, + "95.000000" : 48496640, + "99.000000" : 55836672, + "99.500000" : 58982400, + "99.900000" : 63700992, + "99.950000" : 66322432, + "99.990000" : 69730304 + } + }, + "lat_ns" : { + "min" : 13703235, + "max" : 74210524, + "mean" : 36605204.493923, + "stddev" : 6790863.388984, + "N" : 26245 + }, + "bw_min" : 5005312, + "bw_max" : 5799936, + "bw_agg" : 99.983364, + "bw_mean" : 5365497.125000, + "bw_dev" : 61816.032254, + "bw_samples" : 120, + "iops_min" : 1222, + "iops_max" : 1416, + "iops_mean" : 1309.925000, + "iops_stddev" : 15.094082, + "iops_samples" : 120 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60084, + "usr_cpu" : 0.422741, + "sys_cpu" : 5.462353, + "ctx" : 19740, + "majf" : 0, + "minf" : 49191, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.828539, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.988551, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.742999, + "50" : 95.553439, + "100" : 3.703563, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48795, + "write_ios" : 0, + "read_sectors" : 70985712, + "write_sectors" : 0, + "read_merges" : 3288, + "write_merges" : 0, + "read_ticks" : 1459503, + "write_ticks" : 0, + "in_queue" : 1459503, + "util" : 99.554443 + }, + { + "name" : "vdd", + "read_ios" : 45813, + "write_ios" : 0, + "read_sectors" : 71271048, + "write_sectors" : 0, + "read_merges" : 2737, + "write_merges" : 0, + "read_ticks" : 1378184, + "write_ticks" : 0, + "in_queue" : 1378183, + "util" : 99.564412 + }, + { + "name" : "vde", + "read_ios" : 45777, + "write_ios" : 0, + "read_sectors" : 71153152, + "write_sectors" : 0, + "read_merges" : 4330, + "write_merges" : 0, + "read_ticks" : 1370116, + "write_ticks" : 0, + "in_queue" : 1370117, + "util" : 99.584356 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_1.json new file mode 100644 index 0000000..f538fb2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_1.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675320, + "timestamp_ms" : 1793675320710, + "time" : "Tue Nov 3 03:08:40 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675300605, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 113950851072, + "io_kbytes" : 111280128, + "bw_bytes" : 5687873169, + "bw" : 5554563, + "iops" : 1356.094639, + "runtime" : 20034, + "total_ios" : 27168, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 48201, + "max" : 1642483, + "mean" : 95763.419427, + "stddev" : 62868.133948, + "N" : 27168 + }, + "clat_ns" : { + "min" : 14807326, + "max" : 93894058, + "mean" : 47065404.380190, + "stddev" : 9685844.579476, + "N" : 27168, + "percentile" : { + "1.000000" : 25559040, + "5.000000" : 31850496, + "10.000000" : 34865152, + "20.000000" : 39059456, + "30.000000" : 42205184, + "40.000000" : 44302336, + "50.000000" : 46923776, + "60.000000" : 49020928, + "70.000000" : 51118080, + "80.000000" : 54263808, + "90.000000" : 58982400, + "95.000000" : 63700992, + "99.000000" : 72876032, + "99.500000" : 77070336, + "99.900000" : 83361792, + "99.950000" : 87556096, + "99.990000" : 90701824 + } + }, + "lat_ns" : { + "min" : 14883822, + "max" : 94017312, + "mean" : 47161167.799617, + "stddev" : 9683230.955322, + "N" : 27168 + }, + "bw_min" : 4923392, + "bw_max" : 5971968, + "bw_agg" : 99.948769, + "bw_mean" : 5551718.400000, + "bw_dev" : 60995.647325, + "bw_samples" : 160, + "iops_min" : 1202, + "iops_max" : 1458, + "iops_mean" : 1355.400000, + "iops_stddev" : 14.891515, + "iops_samples" : 160 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80132, + "usr_cpu" : 0.378126, + "sys_cpu" : 4.208057, + "ctx" : 20817, + "majf" : 0, + "minf" : 65585, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.117786, + "16" : 99.779152, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.985246, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.161955, + "50" : 64.310954, + "100" : 35.527091, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 36663, + "write_ios" : 0, + "read_sectors" : 55342504, + "write_sectors" : 0, + "read_merges" : 1698, + "write_merges" : 0, + "read_ticks" : 1398551, + "write_ticks" : 0, + "in_queue" : 1398552, + "util" : 99.559383 + }, + { + "name" : "vdd", + "read_ios" : 36560, + "write_ios" : 0, + "read_sectors" : 55307840, + "write_sectors" : 0, + "read_merges" : 1677, + "write_merges" : 0, + "read_ticks" : 1402466, + "write_ticks" : 0, + "in_queue" : 1402466, + "util" : 99.569354 + }, + { + "name" : "vde", + "read_ios" : 39129, + "write_ios" : 0, + "read_sectors" : 54875048, + "write_sectors" : 0, + "read_merges" : 2532, + "write_merges" : 0, + "read_ticks" : 1503757, + "write_ticks" : 0, + "in_queue" : 1503757, + "util" : 99.599299 + }, + { + "name" : "vdf", + "read_ios" : 36976, + "write_ios" : 0, + "read_sectors" : 55225384, + "write_sectors" : 0, + "read_merges" : 2121, + "write_merges" : 0, + "read_ticks" : 1416146, + "write_ticks" : 0, + "in_queue" : 1416147, + "util" : 99.604288 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_2.json new file mode 100644 index 0000000..aefeaf7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_2.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675484, + "timestamp_ms" : 1793675484159, + "time" : "Tue Nov 3 03:11:24 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675464073, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 118140960768, + "io_kbytes" : 115372032, + "bw_bytes" : 5898789732, + "bw" : 5760536, + "iops" : 1406.381067, + "runtime" : 20028, + "total_ios" : 28167, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 49363, + "max" : 1800607, + "mean" : 89924.229595, + "stddev" : 67088.943813, + "N" : 28167 + }, + "clat_ns" : { + "min" : 14158227, + "max" : 93803377, + "mean" : 45381215.097312, + "stddev" : 9092330.816665, + "N" : 28167, + "percentile" : { + "1.000000" : 25034752, + "5.000000" : 30801920, + "10.000000" : 33816576, + "20.000000" : 38010880, + "30.000000" : 40632320, + "40.000000" : 43253760, + "50.000000" : 45350912, + "60.000000" : 47448064, + "70.000000" : 49545216, + "80.000000" : 52166656, + "90.000000" : 56885248, + "95.000000" : 61079552, + "99.000000" : 69730304, + "99.500000" : 73924608, + "99.900000" : 80216064, + "99.950000" : 82313216, + "99.990000" : 86507520 + } + }, + "lat_ns" : { + "min" : 14327201, + "max" : 93885374, + "mean" : 45471139.326907, + "stddev" : 9089425.409214, + "N" : 28167 + }, + "bw_min" : 5062656, + "bw_max" : 6176768, + "bw_agg" : 99.926676, + "bw_mean" : 5756313.600000, + "bw_dev" : 59770.060917, + "bw_samples" : 160, + "iops_min" : 1236, + "iops_max" : 1508, + "iops_mean" : 1405.350000, + "iops_stddev" : 14.592300, + "iops_samples" : 160 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80103, + "usr_cpu" : 0.309601, + "sys_cpu" : 4.214574, + "ctx" : 21498, + "majf" : 0, + "minf" : 65589, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.113608, + "16" : 99.786985, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.985771, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.131359, + "50" : 72.183761, + "100" : 27.684879, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 36206, + "write_ios" : 0, + "read_sectors" : 57241240, + "write_sectors" : 0, + "read_merges" : 2199, + "write_merges" : 0, + "read_ticks" : 1345185, + "write_ticks" : 0, + "in_queue" : 1345184, + "util" : 99.569397 + }, + { + "name" : "vdd", + "read_ios" : 34047, + "write_ios" : 0, + "read_sectors" : 56934464, + "write_sectors" : 0, + "read_merges" : 2163, + "write_merges" : 0, + "read_ticks" : 1278648, + "write_ticks" : 0, + "in_queue" : 1278648, + "util" : 99.579369 + }, + { + "name" : "vde", + "read_ios" : 33831, + "write_ios" : 0, + "read_sectors" : 57306904, + "write_sectors" : 0, + "read_merges" : 2608, + "write_merges" : 0, + "read_ticks" : 1252775, + "write_ticks" : 0, + "in_queue" : 1252775, + "util" : 99.599319 + }, + { + "name" : "vdf", + "read_ios" : 33939, + "write_ios" : 0, + "read_sectors" : 57567400, + "write_sectors" : 0, + "read_merges" : 2197, + "write_merges" : 0, + "read_ticks" : 1260107, + "write_ticks" : 0, + "in_queue" : 1260107, + "util" : 99.604308 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_3.json new file mode 100644 index 0000000..5d97a8f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/r4_3.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675647, + "timestamp_ms" : 1793675647518, + "time" : "Tue Nov 3 03:14:07 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675627441, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 116840726528, + "io_kbytes" : 114102272, + "bw_bytes" : 5834451539, + "bw" : 5697706, + "iops" : 1391.041646, + "runtime" : 20026, + "total_ios" : 27857, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 50740, + "max" : 1809792, + "mean" : 89721.522813, + "stddev" : 65643.389778, + "N" : 27857 + }, + "clat_ns" : { + "min" : 14313559, + "max" : 94714464, + "mean" : 45880747.244535, + "stddev" : 9240222.446300, + "N" : 27857, + "percentile" : { + "1.000000" : 25296896, + "5.000000" : 31064064, + "10.000000" : 34340864, + "20.000000" : 38535168, + "30.000000" : 41156608, + "40.000000" : 43778048, + "50.000000" : 45875200, + "60.000000" : 47448064, + "70.000000" : 50069504, + "80.000000" : 52690944, + "90.000000" : 57409536, + "95.000000" : 61603840, + "99.000000" : 70778880, + "99.500000" : 74973184, + "99.900000" : 82313216, + "99.950000" : 84410368, + "99.990000" : 89653248 + } + }, + "lat_ns" : { + "min" : 14392123, + "max" : 94787424, + "mean" : 45970468.767348, + "stddev" : 9239365.510747, + "N" : 27857 + }, + "bw_min" : 4842452, + "bw_max" : 6184960, + "bw_agg" : 99.938228, + "bw_mean" : 5694187.667308, + "bw_dev" : 62511.741503, + "bw_samples" : 158, + "iops_min" : 1181, + "iops_max" : 1510, + "iops_mean" : 1390.151282, + "iops_stddev" : 15.289726, + "iops_samples" : 158 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80088, + "usr_cpu" : 0.353361, + "sys_cpu" : 4.159175, + "ctx" : 21527, + "majf" : 0, + "minf" : 65587, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.114872, + "16" : 99.784614, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.985612, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.089744, + "50" : 69.964461, + "100" : 29.945795, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 31472, + "write_ios" : 0, + "read_sectors" : 56663040, + "write_sectors" : 0, + "read_merges" : 3011, + "write_merges" : 0, + "read_ticks" : 1190914, + "write_ticks" : 0, + "in_queue" : 1190913, + "util" : 99.564412 + }, + { + "name" : "vdd", + "read_ios" : 33031, + "write_ios" : 0, + "read_sectors" : 56551784, + "write_sectors" : 0, + "read_merges" : 2139, + "write_merges" : 0, + "read_ticks" : 1248686, + "write_ticks" : 0, + "in_queue" : 1248687, + "util" : 99.574383 + }, + { + "name" : "vde", + "read_ios" : 33107, + "write_ios" : 0, + "read_sectors" : 56769088, + "write_sectors" : 0, + "read_merges" : 3030, + "write_merges" : 0, + "read_ticks" : 1249368, + "write_ticks" : 0, + "in_queue" : 1249369, + "util" : 99.599339 + }, + { + "name" : "vdf", + "read_ios" : 34133, + "write_ios" : 0, + "read_sectors" : 56555088, + "write_sectors" : 0, + "read_merges" : 847, + "write_merges" : 0, + "read_ticks" : 1284139, + "write_ticks" : 0, + "in_queue" : 1284140, + "util" : 99.604327 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_1.json new file mode 100644 index 0000000..1ba0819 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675177, + "timestamp_ms" : 1793675177765, + "time" : "Tue Nov 3 03:06:17 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675157675, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 29620174848, + "io_kbytes" : 28925952, + "bw_bytes" : 1477978885, + "bw" : 1443338, + "iops" : 352.377626, + "runtime" : 20041, + "total_ios" : 7062, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 141164, + "max" : 609876, + "mean" : 304495.381054, + "stddev" : 61908.356784, + "N" : 7062 + }, + "clat_ns" : { + "min" : 15674519, + "max" : 85623056, + "mean" : 45080508.397621, + "stddev" : 4542554.041346, + "N" : 7062, + "percentile" : { + "1.000000" : 36962304, + "5.000000" : 39583744, + "10.000000" : 40632320, + "20.000000" : 42205184, + "30.000000" : 43253760, + "40.000000" : 43778048, + "50.000000" : 44826624, + "60.000000" : 45350912, + "70.000000" : 46399488, + "80.000000" : 47448064, + "90.000000" : 49020928, + "95.000000" : 52166656, + "99.000000" : 65273856, + "99.500000" : 67633152, + "99.900000" : 71827456, + "99.950000" : 76021760, + "99.990000" : 85458944 + } + }, + "lat_ns" : { + "min" : 16119078, + "max" : 86006374, + "mean" : 45385003.778675, + "stddev" : 4557488.931490, + "N" : 7062 + }, + "bw_min" : 1015808, + "bw_max" : 1589248, + "bw_agg" : 99.992119, + "bw_mean" : 1443225.600000, + "bw_dev" : 114521.150427, + "bw_samples" : 40, + "iops_min" : 248, + "iops_max" : 388, + "iops_mean" : 352.350000, + "iops_stddev" : 27.959265, + "iops_samples" : 40 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20040, + "usr_cpu" : 7.729541, + "sys_cpu" : 5.404192, + "ctx" : 6322, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.113282, + "16" : 99.787596, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.985812, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.028321, + "50" : 92.282639, + "100" : 7.689040, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 50, + "write_ios" : 54668, + "read_sectors" : 2104, + "write_sectors" : 57335864, + "read_merges" : 0, + "write_merges" : 3509, + "read_ticks" : 98, + "write_ticks" : 2394158, + "in_queue" : 2394257, + "util" : 99.744630 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_2.json new file mode 100644 index 0000000..3dea8a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_2.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675341, + "timestamp_ms" : 1793675341166, + "time" : "Tue Nov 3 03:09:01 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675321049, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 19918749696, + "io_kbytes" : 19451904, + "bw_bytes" : 992859619, + "bw" : 969589, + "iops" : 236.716180, + "runtime" : 20062, + "total_ios" : 4749, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 170566, + "max" : 29428017, + "mean" : 4150555.375447, + "stddev" : 2647421.618098, + "N" : 4749 + }, + "clat_ns" : { + "min" : 35944280, + "max" : 116800008, + "mean" : 63402349.649400, + "stddev" : 9011067.783262, + "N" : 4749, + "percentile" : { + "1.000000" : 43778048, + "5.000000" : 49020928, + "10.000000" : 52166656, + "20.000000" : 56360960, + "30.000000" : 58458112, + "40.000000" : 60555264, + "50.000000" : 62128128, + "60.000000" : 64225280, + "70.000000" : 67633152, + "80.000000" : 71827456, + "90.000000" : 76021760, + "95.000000" : 79167488, + "99.000000" : 83361792, + "99.500000" : 85458944, + "99.900000" : 99090432, + "99.950000" : 106430464, + "99.990000" : 116916224 + } + }, + "lat_ns" : { + "min" : 36398228, + "max" : 126406102, + "mean" : 67552905.024847, + "stddev" : 9298054.677837, + "N" : 4749 + }, + "bw_min" : 761856, + "bw_max" : 1138688, + "bw_agg" : 99.993144, + "bw_mean" : 969523.200000, + "bw_dev" : 87909.134193, + "bw_samples" : 40, + "iops_min" : 186, + "iops_max" : 278, + "iops_mean" : 236.700000, + "iops_stddev" : 21.462191, + "iops_samples" : 40 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20061, + "usr_cpu" : 11.584667, + "sys_cpu" : 4.007776, + "ctx" : 4941, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.168457, + "16" : 99.684144, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.978881, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 6.443462, + "100" : 93.493367, + "250" : 0.063171, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 43204, + "read_sectors" : 2096, + "write_sectors" : 38525936, + "read_merges" : 0, + "write_merges" : 2065, + "read_ticks" : 94, + "write_ticks" : 2488352, + "in_queue" : 2488447, + "util" : 99.754669 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_3.json new file mode 100644 index 0000000..a48d278 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1_3.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675504, + "timestamp_ms" : 1793675504593, + "time" : "Tue Nov 3 03:11:44 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675484498, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdc", + "filename" : "/dev/vdc" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 19956498432, + "io_kbytes" : 19488768, + "bw_bytes" : 995733880, + "bw" : 972396, + "iops" : 237.401457, + "runtime" : 20042, + "total_ios" : 4758, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 131813, + "max" : 895398, + "mean" : 331904.618537, + "stddev" : 101853.498604, + "N" : 4758 + }, + "clat_ns" : { + "min" : 13755852, + "max" : 88017546, + "mean" : 67037206.048760, + "stddev" : 8661858.331702, + "N" : 4758, + "percentile" : { + "1.000000" : 48496640, + "5.000000" : 53739520, + "10.000000" : 55836672, + "20.000000" : 58458112, + "30.000000" : 61603840, + "40.000000" : 64225280, + "50.000000" : 67633152, + "60.000000" : 69730304, + "70.000000" : 72876032, + "80.000000" : 74973184, + "90.000000" : 78118912, + "95.000000" : 80216064, + "99.000000" : 85458944, + "99.500000" : 85458944, + "99.900000" : 87556096, + "99.950000" : 87556096, + "99.990000" : 87556096 + } + }, + "lat_ns" : { + "min" : 14167552, + "max" : 88753806, + "mean" : 67369110.667297, + "stddev" : 8716335.447749, + "N" : 4758 + }, + "bw_min" : 802816, + "bw_max" : 1171456, + "bw_agg" : 99.894038, + "bw_mean" : 971366.400000, + "bw_dev" : 90367.280363, + "bw_samples" : 40, + "iops_min" : 196, + "iops_max" : 286, + "iops_mean" : 237.150000, + "iops_stddev" : 22.062324, + "iops_samples" : 40 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20041, + "usr_cpu" : 5.668380, + "sys_cpu" : 3.966868, + "ctx" : 4711, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.168138, + "16" : 99.684741, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.978921, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.021017, + "50" : 1.471206, + "100" : 98.507776, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 28179, + "read_sectors" : 2096, + "write_sectors" : 38479896, + "read_merges" : 0, + "write_merges" : 2947, + "read_ticks" : 92, + "write_ticks" : 1855684, + "in_queue" : 1855777, + "util" : 99.764647 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1b.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1b.json new file mode 100644 index 0000000..d794fde --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w1b.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675667, + "timestamp_ms" : 1793675667949, + "time" : "Tue Nov 3 03:14:27 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vde", + "groupid" : 0, + "job_start" : 1793675647853, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 26688356352, + "io_kbytes" : 26062848, + "bw_bytes" : 1331422117, + "bw" : 1300216, + "iops" : 317.435770, + "runtime" : 20045, + "total_ios" : 6363, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 122631, + "max" : 967868, + "mean" : 510288.571743, + "stddev" : 181853.709432, + "N" : 6363 + }, + "clat_ns" : { + "min" : 13964519, + "max" : 87899668, + "mean" : 49871670.796165, + "stddev" : 5002767.057749, + "N" : 6363, + "percentile" : { + "1.000000" : 41680896, + "5.000000" : 43778048, + "10.000000" : 44826624, + "20.000000" : 45875200, + "30.000000" : 46923776, + "40.000000" : 47972352, + "50.000000" : 49020928, + "60.000000" : 50069504, + "70.000000" : 51118080, + "80.000000" : 52690944, + "90.000000" : 57409536, + "95.000000" : 60030976, + "99.000000" : 63700992, + "99.500000" : 64749568, + "99.900000" : 77070336, + "99.950000" : 79167488, + "99.990000" : 87556096 + } + }, + "lat_ns" : { + "min" : 14421721, + "max" : 88215896, + "mean" : 50381959.367908, + "stddev" : 4932747.433092, + "N" : 6363 + }, + "bw_min" : 1087361, + "bw_max" : 1458176, + "bw_agg" : 99.984548, + "bw_mean" : 1300016.025000, + "bw_dev" : 98532.302023, + "bw_samples" : 40, + "iops_min" : 265, + "iops_max" : 356, + "iops_mean" : 317.375000, + "iops_stddev" : 24.081792, + "iops_samples" : 40 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 20044, + "usr_cpu" : 13.635003, + "sys_cpu" : 4.644781, + "ctx" : 5745, + "majf" : 0, + "minf" : 11, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.125727, + "16" : 99.764262, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.984249, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.031432, + "50" : 60.317460, + "100" : 39.651108, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vde", + "read_ios" : 50, + "write_ios" : 48819, + "read_sectors" : 2104, + "write_sectors" : 51607552, + "read_merges" : 0, + "write_merges" : 2370, + "read_ticks" : 81, + "write_ticks" : 2367183, + "in_queue" : 2367265, + "util" : 99.724628 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_1.json new file mode 100644 index 0000000..59d8c48 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_1.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675198, + "timestamp_ms" : 1793675198220, + "time" : "Tue Nov 3 03:06:38 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675178105, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 48477765632, + "io_kbytes" : 47341568, + "bw_bytes" : 2417602515, + "bw" : 2360939, + "iops" : 576.401356, + "runtime" : 20052, + "total_ios" : 11558, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 143529, + "max" : 970657, + "mean" : 457885.524226, + "stddev" : 157663.156307, + "N" : 11558 + }, + "clat_ns" : { + "min" : 16530952, + "max" : 103813774, + "mean" : 55030761.898858, + "stddev" : 5397410.118783, + "N" : 11558, + "percentile" : { + "1.000000" : 44826624, + "5.000000" : 47448064, + "10.000000" : 49020928, + "20.000000" : 50069504, + "30.000000" : 51642368, + "40.000000" : 53215232, + "50.000000" : 54788096, + "60.000000" : 56360960, + "70.000000" : 57933824, + "80.000000" : 59506688, + "90.000000" : 62128128, + "95.000000" : 63700992, + "99.000000" : 67633152, + "99.500000" : 69730304, + "99.900000" : 84410368, + "99.950000" : 95944704, + "99.990000" : 100139008 + } + }, + "lat_ns" : { + "min" : 17125418, + "max" : 104411297, + "mean" : 55488647.423084, + "stddev" : 5409203.071698, + "N" : 11558 + }, + "bw_min" : 2105344, + "bw_max" : 2637824, + "bw_agg" : 99.999748, + "bw_mean" : 2360934.400000, + "bw_dev" : 84496.515148, + "bw_samples" : 80, + "iops_min" : 514, + "iops_max" : 644, + "iops_mean" : 576.400000, + "iops_stddev" : 20.629032, + "iops_samples" : 80 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40101, + "usr_cpu" : 10.827660, + "sys_cpu" : 4.516097, + "ctx" : 10476, + "majf" : 0, + "minf" : 25, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.138432, + "16" : 99.740440, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.982654, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.051912, + "50" : 17.347292, + "100" : 82.583492, + "250" : 0.017304, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 36182, + "read_sectors" : 2096, + "write_sectors" : 46972928, + "read_merges" : 0, + "write_merges" : 3595, + "read_ticks" : 94, + "write_ticks" : 1945852, + "in_queue" : 1945946, + "util" : 99.719579 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 36050, + "read_sectors" : 2112, + "write_sectors" : 46787600, + "read_merges" : 0, + "write_merges" : 2864, + "read_ticks" : 97, + "write_ticks" : 1927519, + "in_queue" : 1927617, + "util" : 99.759615 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_2.json new file mode 100644 index 0000000..735b189 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_2.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675361, + "timestamp_ms" : 1793675361627, + "time" : "Tue Nov 3 03:09:21 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675341497, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 38805700608, + "io_kbytes" : 37896192, + "bw_bytes" : 1932554811, + "bw" : 1887260, + "iops" : 460.756972, + "runtime" : 20080, + "total_ios" : 9252, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 179151, + "max" : 906271, + "mean" : 498189.222006, + "stddev" : 107786.992155, + "N" : 9252 + }, + "clat_ns" : { + "min" : 27122512, + "max" : 140688570, + "mean" : 68919383.341548, + "stddev" : 8535753.212926, + "N" : 9252, + "percentile" : { + "1.000000" : 55312384, + "5.000000" : 58458112, + "10.000000" : 60030976, + "20.000000" : 62128128, + "30.000000" : 63700992, + "40.000000" : 65273856, + "50.000000" : 67633152, + "60.000000" : 68681728, + "70.000000" : 71827456, + "80.000000" : 76021760, + "90.000000" : 81264640, + "95.000000" : 84410368, + "99.000000" : 92798976, + "99.500000" : 94896128, + "99.900000" : 123207680, + "99.950000" : 133693440, + "99.990000" : 141557760 + } + }, + "lat_ns" : { + "min" : 27486914, + "max" : 141229897, + "mean" : 69417572.563554, + "stddev" : 8586593.398895, + "N" : 9252 + }, + "bw_min" : 1572864, + "bw_max" : 2211840, + "bw_agg" : 100.000000, + "bw_mean" : 1888665.600000, + "bw_dev" : 79990.033396, + "bw_samples" : 80, + "iops_min" : 384, + "iops_max" : 540, + "iops_mean" : 461.100000, + "iops_stddev" : 19.528817, + "iops_samples" : 80 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40158, + "usr_cpu" : 9.811246, + "sys_cpu" : 3.140097, + "ctx" : 9140, + "majf" : 0, + "minf" : 25, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.172936, + "16" : 99.675746, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.978317, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.194553, + "100" : 99.589278, + "250" : 0.216169, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 29769, + "read_sectors" : 2096, + "write_sectors" : 37538304, + "read_merges" : 0, + "write_merges" : 2300, + "read_ticks" : 102, + "write_ticks" : 2007858, + "in_queue" : 2007961, + "util" : 99.789716 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 27687, + "read_sectors" : 2112, + "write_sectors" : 37435424, + "read_merges" : 0, + "write_merges" : 2866, + "read_ticks" : 102, + "write_ticks" : 1872679, + "in_queue" : 1872781, + "util" : 99.819739 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_3.json new file mode 100644 index 0000000..df1c361 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2_3.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675525, + "timestamp_ms" : 1793675525030, + "time" : "Tue Nov 3 03:12:05 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675504925, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdd", + "filename" : "/dev/vdd" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 46212841472, + "io_kbytes" : 45129728, + "bw_bytes" : 2304075458, + "bw" : 2250073, + "iops" : 549.334397, + "runtime" : 20057, + "total_ios" : 11018, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 133371, + "max" : 916649, + "mean" : 439206.197132, + "stddev" : 149285.418703, + "N" : 11018 + }, + "clat_ns" : { + "min" : 14614151, + "max" : 113628093, + "mean" : 57777364.402523, + "stddev" : 4170575.793760, + "N" : 11018, + "percentile" : { + "1.000000" : 49020928, + "5.000000" : 51642368, + "10.000000" : 53215232, + "20.000000" : 54788096, + "30.000000" : 55836672, + "40.000000" : 56885248, + "50.000000" : 57409536, + "60.000000" : 58458112, + "70.000000" : 59506688, + "80.000000" : 60555264, + "90.000000" : 62652416, + "95.000000" : 64225280, + "99.000000" : 67633152, + "99.500000" : 69730304, + "99.900000" : 88604672, + "99.950000" : 100139008, + "99.990000" : 108527616 + } + }, + "lat_ns" : { + "min" : 15090688, + "max" : 114338734, + "mean" : 58216570.599655, + "stddev" : 4174105.210470, + "N" : 11018 + }, + "bw_min" : 2072576, + "bw_max" : 2392064, + "bw_agg" : 100.000000, + "bw_mean" : 2250342.400000, + "bw_dev" : 35816.771930, + "bw_samples" : 80, + "iops_min" : 506, + "iops_max" : 584, + "iops_mean" : 549.400000, + "iops_stddev" : 8.744329, + "iops_samples" : 80 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40106, + "usr_cpu" : 10.148108, + "sys_cpu" : 4.109111, + "ctx" : 10631, + "majf" : 0, + "minf" : 24, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.145217, + "16" : 99.727718, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.981802, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.018152, + "50" : 1.724451, + "100" : 98.202941, + "250" : 0.054456, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 50, + "write_ios" : 29973, + "read_sectors" : 2104, + "write_sectors" : 44662840, + "read_merges" : 0, + "write_merges" : 2392, + "read_ticks" : 87, + "write_ticks" : 1701567, + "in_queue" : 1701655, + "util" : 99.734602 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 27621, + "read_sectors" : 2112, + "write_sectors" : 44695552, + "read_merges" : 0, + "write_merges" : 3078, + "read_ticks" : 87, + "write_ticks" : 1555121, + "in_queue" : 1555208, + "util" : 99.759615 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2b.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2b.json new file mode 100644 index 0000000..27a2655 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w2b.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675688, + "timestamp_ms" : 1793675688398, + "time" : "Tue Nov 3 03:14:48 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vde", + "groupid" : 0, + "job_start" : 1793675668279, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 45478838272, + "io_kbytes" : 44412928, + "bw_bytes" : 2267592654, + "bw" : 2214445, + "iops" : 540.636219, + "runtime" : 20056, + "total_ios" : 10843, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158832, + "max" : 671417, + "mean" : 324144.678226, + "stddev" : 63066.519511, + "N" : 10843 + }, + "clat_ns" : { + "min" : 14567307, + "max" : 111286535, + "mean" : 58837099.629070, + "stddev" : 4770609.033242, + "N" : 10843, + "percentile" : { + "1.000000" : 50069504, + "5.000000" : 52690944, + "10.000000" : 53739520, + "20.000000" : 55312384, + "30.000000" : 56360960, + "40.000000" : 57409536, + "50.000000" : 58458112, + "60.000000" : 59506688, + "70.000000" : 60555264, + "80.000000" : 62128128, + "90.000000" : 64749568, + "95.000000" : 67633152, + "99.000000" : 71827456, + "99.500000" : 73924608, + "99.900000" : 88604672, + "99.950000" : 98041856, + "99.990000" : 107479040 + } + }, + "lat_ns" : { + "min" : 15063511, + "max" : 111547139, + "mean" : 59161244.307295, + "stddev" : 4787362.272060, + "N" : 10843 + }, + "bw_min" : 2015232, + "bw_max" : 2392064, + "bw_agg" : 100.000000, + "bw_mean" : 2214502.400000, + "bw_dev" : 51492.314712, + "bw_samples" : 80, + "iops_min" : 492, + "iops_max" : 584, + "iops_mean" : 540.650000, + "iops_stddev" : 12.571366, + "iops_samples" : 80 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 40108, + "usr_cpu" : 6.831555, + "sys_cpu" : 3.734916, + "ctx" : 10474, + "majf" : 0, + "minf" : 26, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.147561, + "16" : 99.723324, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.981507, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.036890, + "50" : 0.977589, + "100" : 98.939408, + "250" : 0.046113, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vde", + "read_ios" : 49, + "write_ios" : 34505, + "read_sectors" : 2096, + "write_sectors" : 43909120, + "read_merges" : 0, + "write_merges" : 3360, + "read_ticks" : 88, + "write_ticks" : 1992822, + "in_queue" : 1992910, + "util" : 99.714572 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 32245, + "read_sectors" : 2112, + "write_sectors" : 44032000, + "read_merges" : 0, + "write_merges" : 3033, + "read_ticks" : 84, + "write_ticks" : 1850466, + "in_queue" : 1850551, + "util" : 99.759615 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_1.json new file mode 100644 index 0000000..8ca1969 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_1.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675218, + "timestamp_ms" : 1793675218699, + "time" : "Tue Nov 3 03:06:58 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675198570, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 44405096448, + "io_kbytes" : 43364352, + "bw_bytes" : 2211739624, + "bw" : 2159901, + "iops" : 527.319819, + "runtime" : 20077, + "total_ios" : 10587, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 150550, + "max" : 896441, + "mean" : 518532.862851, + "stddev" : 131501.330650, + "N" : 10587 + }, + "clat_ns" : { + "min" : 15710722, + "max" : 176945105, + "mean" : 90450178.492963, + "stddev" : 11265006.963370, + "N" : 10587, + "percentile" : { + "1.000000" : 62128128, + "5.000000" : 72876032, + "10.000000" : 77070336, + "20.000000" : 82313216, + "30.000000" : 85458944, + "40.000000" : 88604672, + "50.000000" : 90701824, + "60.000000" : 92798976, + "70.000000" : 95944704, + "80.000000" : 99090432, + "90.000000" : 103284736, + "95.000000" : 106430464, + "99.000000" : 120061952, + "99.500000" : 132644864, + "99.900000" : 154140672, + "99.950000" : 162529280, + "99.990000" : 170917888 + } + }, + "lat_ns" : { + "min" : 16166442, + "max" : 177342361, + "mean" : 90968711.355814, + "stddev" : 11279377.291134, + "N" : 10587 + }, + "bw_min" : 1884160, + "bw_max" : 2473984, + "bw_agg" : 99.961573, + "bw_mean" : 2159072.175000, + "bw_dev" : 42002.672216, + "bw_samples" : 120, + "iops_min" : 460, + "iops_max" : 604, + "iops_mean" : 527.100000, + "iops_stddev" : 10.257033, + "iops_samples" : 120 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60217, + "usr_cpu" : 7.559327, + "sys_cpu" : 3.055616, + "ctx" : 9088, + "majf" : 0, + "minf" : 40, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.113347, + "8" : 0.226693, + "16" : 99.574950, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.971550, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.018891, + "50" : 0.170020, + "100" : 83.045244, + "250" : 16.765845, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 17710, + "read_sectors" : 2096, + "write_sectors" : 29029376, + "read_merges" : 0, + "write_merges" : 2001, + "read_ticks" : 81, + "write_ticks" : 1548095, + "in_queue" : 1548175, + "util" : 99.714515 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 19530, + "read_sectors" : 2112, + "write_sectors" : 28442624, + "read_merges" : 0, + "write_merges" : 2180, + "read_ticks" : 85, + "write_ticks" : 1723629, + "in_queue" : 1723713, + "util" : 99.714486 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 21801, + "read_sectors" : 2112, + "write_sectors" : 28301312, + "read_merges" : 0, + "write_merges" : 1519, + "read_ticks" : 79, + "write_ticks" : 1933935, + "in_queue" : 1934015, + "util" : 99.754509 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_2.json new file mode 100644 index 0000000..47012d7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_2.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675382, + "timestamp_ms" : 1793675382116, + "time" : "Tue Nov 3 03:09:42 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675361980, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 41779462144, + "io_kbytes" : 40800256, + "bw_bytes" : 2080339697, + "bw" : 2031581, + "iops" : 495.991635, + "runtime" : 20083, + "total_ios" : 9961, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158681, + "max" : 758283, + "mean" : 417946.352876, + "stddev" : 79318.203326, + "N" : 9961 + }, + "clat_ns" : { + "min" : 21627247, + "max" : 192283793, + "mean" : 96291537.828431, + "stddev" : 13116935.200846, + "N" : 9961, + "percentile" : { + "1.000000" : 67633152, + "5.000000" : 76021760, + "10.000000" : 80216064, + "20.000000" : 86507520, + "30.000000" : 89653248, + "40.000000" : 92798976, + "50.000000" : 95944704, + "60.000000" : 99090432, + "70.000000" : 102236160, + "80.000000" : 106430464, + "90.000000" : 112721920, + "95.000000" : 119013376, + "99.000000" : 129499136, + "99.500000" : 133693440, + "99.900000" : 168820736, + "99.950000" : 177209344, + "99.990000" : 191889408 + } + }, + "lat_ns" : { + "min" : 22097962, + "max" : 192760380, + "mean" : 96709484.181307, + "stddev" : 13129865.608722, + "N" : 9961 + }, + "bw_min" : 1753088, + "bw_max" : 2293760, + "bw_agg" : 99.959650, + "bw_mean" : 2030762.850000, + "bw_dev" : 42670.490397, + "bw_samples" : 120, + "iops_min" : 428, + "iops_max" : 560, + "iops_mean" : 495.775000, + "iops_stddev" : 10.417896, + "iops_samples" : 120 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60233, + "usr_cpu" : 5.928644, + "sys_cpu" : 2.020487, + "ctx" : 8789, + "majf" : 0, + "minf" : 38, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.120470, + "8" : 0.240940, + "16" : 99.548238, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.969755, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.160626, + "100" : 63.999598, + "250" : 35.839775, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48, + "write_ios" : 18279, + "read_sectors" : 2088, + "write_sectors" : 26940416, + "read_merges" : 0, + "write_merges" : 1652, + "read_ticks" : 61, + "write_ticks" : 1719156, + "in_queue" : 1719217, + "util" : 99.589466 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 17549, + "read_sectors" : 2112, + "write_sectors" : 26749440, + "read_merges" : 0, + "write_merges" : 1640, + "read_ticks" : 73, + "write_ticks" : 1656038, + "in_queue" : 1656111, + "util" : 99.644502 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 18330, + "read_sectors" : 2112, + "write_sectors" : 26997776, + "read_merges" : 0, + "write_merges" : 1242, + "read_ticks" : 66, + "write_ticks" : 1711808, + "in_queue" : 1711873, + "util" : 99.659455 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_3.json new file mode 100644 index 0000000..5a90894 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w3_3.json @@ -0,0 +1,303 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675545, + "timestamp_ms" : 1793675545503, + "time" : "Tue Nov 3 03:12:25 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675525363, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vde", + "filename" : "/dev/vde" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 44535119872, + "io_kbytes" : 43491328, + "bw_bytes" : 2218547368, + "bw" : 2166550, + "iops" : 528.942911, + "runtime" : 20074, + "total_ios" : 10618, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 144929, + "max" : 1050400, + "mean" : 431171.790262, + "stddev" : 123042.413394, + "N" : 10618 + }, + "clat_ns" : { + "min" : 14709535, + "max" : 191763127, + "mean" : 90269257.846864, + "stddev" : 15067238.415762, + "N" : 10618, + "percentile" : { + "1.000000" : 57933824, + "5.000000" : 66846720, + "10.000000" : 71827456, + "20.000000" : 77070336, + "30.000000" : 82313216, + "40.000000" : 86507520, + "50.000000" : 90701824, + "60.000000" : 93847552, + "70.000000" : 98041856, + "80.000000" : 102236160, + "90.000000" : 108527616, + "95.000000" : 113770496, + "99.000000" : 128450560, + "99.500000" : 143654912, + "99.900000" : 156237824, + "99.950000" : 166723584, + "99.990000" : 181403648 + } + }, + "lat_ns" : { + "min" : 15184069, + "max" : 192295431, + "mean" : 90700429.637126, + "stddev" : 15098124.747470, + "N" : 10618 + }, + "bw_min" : 1484475, + "bw_max" : 2727936, + "bw_agg" : 99.946590, + "bw_mean" : 2165393.475000, + "bw_dev" : 72781.548870, + "bw_samples" : 120, + "iops_min" : 362, + "iops_max" : 666, + "iops_mean" : 528.650000, + "iops_stddev" : 17.782179, + "iops_samples" : 120 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60214, + "usr_cpu" : 6.448666, + "sys_cpu" : 2.349952, + "ctx" : 6820, + "majf" : 0, + "minf" : 40, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.113016, + "8" : 0.226031, + "16" : 99.576191, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.971634, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.018836, + "50" : 0.131852, + "100" : 75.042381, + "250" : 24.806932, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48, + "write_ios" : 19746, + "read_sectors" : 2088, + "write_sectors" : 30113792, + "read_merges" : 0, + "write_merges" : 1847, + "read_ticks" : 62, + "write_ticks" : 1663880, + "in_queue" : 1663943, + "util" : 99.644449 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 19173, + "read_sectors" : 2112, + "write_sectors" : 28565504, + "read_merges" : 0, + "write_merges" : 1314, + "read_ticks" : 86, + "write_ticks" : 1678115, + "in_queue" : 1678201, + "util" : 99.699519 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 17109, + "read_sectors" : 2112, + "write_sectors" : 27367440, + "read_merges" : 0, + "write_merges" : 1468, + "read_ticks" : 81, + "write_ticks" : 1568028, + "in_queue" : 1568109, + "util" : 99.709477 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_1.json new file mode 100644 index 0000000..e66c1d7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_1.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675239, + "timestamp_ms" : 1793675239178, + "time" : "Tue Nov 3 03:07:19 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675219046, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 44979716096, + "io_kbytes" : 43925504, + "bw_bytes" : 2239914152, + "bw" : 2187416, + "iops" : 534.037150, + "runtime" : 20081, + "total_ios" : 10724, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 199444, + "max" : 875394, + "mean" : 428903.927266, + "stddev" : 95133.825994, + "N" : 10724 + }, + "clat_ns" : { + "min" : 24750696, + "max" : 183350610, + "mean" : 119308053.631574, + "stddev" : 15756134.758053, + "N" : 10724, + "percentile" : { + "1.000000" : 80216064, + "5.000000" : 92798976, + "10.000000" : 99090432, + "20.000000" : 106430464, + "30.000000" : 111673344, + "40.000000" : 115867648, + "50.000000" : 120061952, + "60.000000" : 124256256, + "70.000000" : 127401984, + "80.000000" : 132644864, + "90.000000" : 137363456, + "95.000000" : 143654912, + "99.000000" : 154140672, + "99.500000" : 158334976, + "99.900000" : 168820736, + "99.950000" : 170917888, + "99.990000" : 181403648 + } + }, + "lat_ns" : { + "min" : 25218462, + "max" : 183746805, + "mean" : 119736957.558840, + "stddev" : 15769235.247577, + "N" : 10724 + }, + "bw_min" : 1875968, + "bw_max" : 2539520, + "bw_agg" : 99.842044, + "bw_mean" : 2183961.025000, + "bw_dev" : 36050.013452, + "bw_samples" : 160, + "iops_min" : 458, + "iops_max" : 620, + "iops_mean" : 533.175000, + "iops_stddev" : 8.804364, + "iops_samples" : 160 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80284, + "usr_cpu" : 4.759354, + "sys_cpu" : 1.974241, + "ctx" : 10255, + "majf" : 0, + "minf" : 52, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.149198, + "8" : 0.298396, + "16" : 99.440507, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.962505, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.083924, + "100" : 11.077956, + "250" : 88.838120, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 14041, + "read_sectors" : 2096, + "write_sectors" : 21659648, + "read_merges" : 0, + "write_merges" : 830, + "read_ticks" : 71, + "write_ticks" : 1640594, + "in_queue" : 1640664, + "util" : 99.624418 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 14140, + "read_sectors" : 2112, + "write_sectors" : 21569536, + "read_merges" : 0, + "write_merges" : 827, + "read_ticks" : 76, + "write_ticks" : 1657853, + "in_queue" : 1657929, + "util" : 99.649422 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 13910, + "read_sectors" : 2112, + "write_sectors" : 21723168, + "read_merges" : 0, + "write_merges" : 832, + "read_ticks" : 70, + "write_ticks" : 1618868, + "in_queue" : 1618938, + "util" : 99.669388 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 14383, + "read_sectors" : 2112, + "write_sectors" : 21684224, + "read_merges" : 0, + "write_merges" : 830, + "read_ticks" : 75, + "write_ticks" : 1678730, + "in_queue" : 1678804, + "util" : 99.679375 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_2.json new file mode 100644 index 0000000..1889793 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_2.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675402, + "timestamp_ms" : 1793675402606, + "time" : "Tue Nov 3 03:10:02 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675382465, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 39921385472, + "io_kbytes" : 38985728, + "bw_bytes" : 1987621880, + "bw" : 1941036, + "iops" : 473.885985, + "runtime" : 20085, + "total_ios" : 9518, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 203890, + "max" : 804479, + "mean" : 444331.177768, + "stddev" : 89256.708928, + "N" : 9518 + }, + "clat_ns" : { + "min" : 17994029, + "max" : 230827270, + "mean" : 134524847.246691, + "stddev" : 22813776.326463, + "N" : 9518, + "percentile" : { + "1.000000" : 88604672, + "5.000000" : 100139008, + "10.000000" : 107479040, + "20.000000" : 116916224, + "30.000000" : 122159104, + "40.000000" : 127401984, + "50.000000" : 132644864, + "60.000000" : 137363456, + "70.000000" : 143654912, + "80.000000" : 152043520, + "90.000000" : 164626432, + "95.000000" : 177209344, + "99.000000" : 198180864, + "99.500000" : 204472320, + "99.900000" : 219152384, + "99.950000" : 223346688, + "99.990000" : 231735296 + } + }, + "lat_ns" : { + "min" : 18567193, + "max" : 231090144, + "mean" : 134969178.424459, + "stddev" : 22848634.140860, + "N" : 9518 + }, + "bw_min" : 1425408, + "bw_max" : 2392064, + "bw_agg" : 99.791916, + "bw_mean" : 1936998.400000, + "bw_dev" : 56858.001644, + "bw_samples" : 160, + "iops_min" : 348, + "iops_max" : 584, + "iops_mean" : 472.900000, + "iops_stddev" : 13.881348, + "iops_samples" : 160 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80326, + "usr_cpu" : 4.486717, + "sys_cpu" : 1.645793, + "ctx" : 9370, + "majf" : 0, + "minf" : 54, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.168103, + "8" : 0.336205, + "16" : 99.369615, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.957726, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.010506, + "50" : 0.073545, + "100" : 4.980038, + "250" : 94.935911, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 48, + "write_ios" : 12056, + "read_sectors" : 2088, + "write_sectors" : 19272704, + "read_merges" : 0, + "write_merges" : 888, + "read_ticks" : 89, + "write_ticks" : 1583588, + "in_queue" : 1583677, + "util" : 99.689472 + }, + { + "name" : "vdd", + "read_ios" : 50, + "write_ios" : 11716, + "read_sectors" : 2104, + "write_sectors" : 19210240, + "read_merges" : 0, + "write_merges" : 588, + "read_ticks" : 76, + "write_ticks" : 1544060, + "in_queue" : 1544136, + "util" : 99.624324 + }, + { + "name" : "vde", + "read_ios" : 49, + "write_ios" : 11821, + "read_sectors" : 2096, + "write_sectors" : 19131544, + "read_merges" : 0, + "write_merges" : 1028, + "read_ticks" : 75, + "write_ticks" : 1563534, + "in_queue" : 1563609, + "util" : 99.634250 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 11220, + "read_sectors" : 2112, + "write_sectors" : 19109920, + "read_merges" : 0, + "write_merges" : 1025, + "read_ticks" : 94, + "write_ticks" : 1487762, + "in_queue" : 1487856, + "util" : 99.754472 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_3.json new file mode 100644 index 0000000..88c48c6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/baseline2/w4_3.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793675566, + "timestamp_ms" : 1793675566003, + "time" : "Tue Nov 3 03:12:46 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "size" : "48G", + "runtime" : "20" + }, + "jobs" : [ + { + "jobname" : "vdc", + "groupid" : 0, + "job_start" : 1793675545848, + "error" : 0, + "eta" : 0, + "elapsed" : 21, + "job options" : { + "name" : "vdf", + "filename" : "/dev/vdf" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 40164655104, + "io_kbytes" : 39223296, + "bw_bytes" : 1998539836, + "bw" : 1951699, + "iops" : 476.489028, + "runtime" : 20097, + "total_ios" : 9576, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 184929, + "max" : 859828, + "mean" : 430771.088346, + "stddev" : 91347.213379, + "N" : 9576 + }, + "clat_ns" : { + "min" : 15811325, + "max" : 233989443, + "mean" : 133780958.453530, + "stddev" : 17280779.307415, + "N" : 9576, + "percentile" : { + "1.000000" : 90701824, + "5.000000" : 105381888, + "10.000000" : 112721920, + "20.000000" : 120061952, + "30.000000" : 125304832, + "40.000000" : 130547712, + "50.000000" : 135266304, + "60.000000" : 139460608, + "70.000000" : 143654912, + "80.000000" : 147849216, + "90.000000" : 154140672, + "95.000000" : 160432128, + "99.000000" : 173015040, + "99.500000" : 181403648, + "99.900000" : 208666624, + "99.950000" : 219152384, + "99.990000" : 233832448 + } + }, + "lat_ns" : { + "min" : 16226695, + "max" : 234322911, + "mean" : 134211729.541876, + "stddev" : 17292474.969199, + "N" : 9576 + }, + "bw_min" : 1598982, + "bw_max" : 2293760, + "bw_agg" : 99.848795, + "bw_mean" : 1948748.875000, + "bw_dev" : 36304.846382, + "bw_samples" : 160, + "iops_min" : 390, + "iops_max" : 560, + "iops_mean" : 475.625000, + "iops_stddev" : 8.883019, + "iops_samples" : 160 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 80362, + "usr_cpu" : 4.326672, + "sys_cpu" : 1.712252, + "ctx" : 9036, + "majf" : 0, + "minf" : 52, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.167084, + "8" : 0.334169, + "16" : 99.373434, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.957983, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.010443, + "50" : 0.062657, + "100" : 2.788221, + "250" : 97.138680, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "vdc", + "read_ios" : 49, + "write_ios" : 11300, + "read_sectors" : 2096, + "write_sectors" : 19249112, + "read_merges" : 0, + "write_merges" : 591, + "read_ticks" : 90, + "write_ticks" : 1486694, + "in_queue" : 1486784, + "util" : 99.724490 + }, + { + "name" : "vdd", + "read_ios" : 51, + "write_ios" : 11252, + "read_sectors" : 2112, + "write_sectors" : 19158016, + "read_merges" : 0, + "write_merges" : 735, + "read_ticks" : 94, + "write_ticks" : 1485748, + "in_queue" : 1485842, + "util" : 99.764541 + }, + { + "name" : "vde", + "read_ios" : 51, + "write_ios" : 11646, + "read_sectors" : 2112, + "write_sectors" : 19335680, + "read_merges" : 0, + "write_merges" : 592, + "read_ticks" : 91, + "write_ticks" : 1522714, + "in_queue" : 1522806, + "util" : 99.784526 + }, + { + "name" : "vdf", + "read_ios" : 51, + "write_ios" : 11815, + "read_sectors" : 2112, + "write_sectors" : 19619840, + "read_merges" : 0, + "write_merges" : 601, + "read_ticks" : 79, + "write_ticks" : 1526151, + "in_queue" : 1526229, + "util" : 99.774481 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.cpu new file mode 100644 index 0000000..003b8f6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.5996630191803, "user_s": 51.211572, "sys_s": 7.796186, "max_rss_kb": 4479188} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.json new file mode 100644 index 0000000..0a96caa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1729.98, + "duration_min_ms": 1448.88, + "duration_max_ms": 1992.85, + "duration_p50_ms": 1732.54, + "duration_p99_ms": 1992.85, + "duration_std_ms": 185.34, + "throughput_avg_mbps": 1047.28, + "throughput_min_mbps": 899.21, + "throughput_max_mbps": 1236.81, + "ops_per_sec_avg": 74.81, + "latency_per_key_ms": 13.515 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 13.48, + "duration_min_ms": 5.73, + "duration_max_ms": 29.7, + "duration_p50_ms": 10.94, + "duration_p99_ms": 29.7, + "duration_std_ms": 7.75, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12622.09, + "latency_per_key_ms": 0.105 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 838.17, + "duration_min_ms": 617.79, + "duration_max_ms": 873.37, + "duration_p50_ms": 862.66, + "duration_p99_ms": 873.37, + "duration_std_ms": 71.88, + "throughput_avg_mbps": 2156.76, + "throughput_min_mbps": 2051.82, + "throughput_max_mbps": 2900.66, + "ops_per_sec_avg": 154.05, + "latency_per_key_ms": 6.548 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.cpu new file mode 100644 index 0000000..3a30e35 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 37.83126974105835, "user_s": 46.640865, "sys_s": 7.780074, "max_rss_kb": 4480260} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.json new file mode 100644 index 0000000..3dac345 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1497.96, + "duration_min_ms": 1143.47, + "duration_max_ms": 1746.83, + "duration_p50_ms": 1491.32, + "duration_p99_ms": 1746.83, + "duration_std_ms": 181.99, + "throughput_avg_mbps": 1213.96, + "throughput_min_mbps": 1025.86, + "throughput_max_mbps": 1567.16, + "ops_per_sec_avg": 86.71, + "latency_per_key_ms": 11.703 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 9.76, + "duration_min_ms": 5.87, + "duration_max_ms": 22.67, + "duration_p50_ms": 6.04, + "duration_p99_ms": 22.67, + "duration_std_ms": 5.96, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 16808.26, + "latency_per_key_ms": 0.076 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 853.13, + "duration_min_ms": 605.84, + "duration_max_ms": 880.23, + "duration_p50_ms": 876.61, + "duration_p99_ms": 880.23, + "duration_std_ms": 78.04, + "throughput_avg_mbps": 2122.58, + "throughput_min_mbps": 2035.82, + "throughput_max_mbps": 2957.88, + "ops_per_sec_avg": 151.61, + "latency_per_key_ms": 6.665 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.cpu new file mode 100644 index 0000000..b77e1c1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 39.887633323669434, "user_s": 50.266635, "sys_s": 8.046305, "max_rss_kb": 4479800} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.json new file mode 100644 index 0000000..122727e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1617.72, + "duration_min_ms": 1463.83, + "duration_max_ms": 1859.2, + "duration_p50_ms": 1603.13, + "duration_p99_ms": 1859.2, + "duration_std_ms": 115.89, + "throughput_avg_mbps": 1112.82, + "throughput_min_mbps": 963.86, + "throughput_max_mbps": 1224.19, + "ops_per_sec_avg": 79.49, + "latency_per_key_ms": 12.638 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 9.33, + "duration_min_ms": 4.27, + "duration_max_ms": 21.9, + "duration_p50_ms": 5.87, + "duration_p99_ms": 21.9, + "duration_std_ms": 5.7, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 18476.93, + "latency_per_key_ms": 0.073 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 840.8, + "duration_min_ms": 553.1, + "duration_max_ms": 873.61, + "duration_p50_ms": 862.69, + "duration_p99_ms": 873.61, + "duration_std_ms": 90.72, + "throughput_avg_mbps": 2164.81, + "throughput_min_mbps": 2051.27, + "throughput_max_mbps": 3239.92, + "ops_per_sec_avg": 154.63, + "latency_per_key_ms": 6.569 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.cpu new file mode 100644 index 0000000..569eda3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.15934133529663, "user_s": 45.418772, "sys_s": 8.300351, "max_rss_kb": 4445116} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.json new file mode 100644 index 0000000..015536c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1729.66, + "duration_min_ms": 1508.38, + "duration_max_ms": 1962.34, + "duration_p50_ms": 1696.88, + "duration_p99_ms": 1962.34, + "duration_std_ms": 146.53, + "throughput_avg_mbps": 1042.85, + "throughput_min_mbps": 913.2, + "throughput_max_mbps": 1188.03, + "ops_per_sec_avg": 74.49, + "latency_per_key_ms": 13.513 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 8.07, + "duration_min_ms": 5.58, + "duration_max_ms": 13.13, + "duration_p50_ms": 6.3, + "duration_p99_ms": 13.13, + "duration_std_ms": 2.65, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 17297.0, + "latency_per_key_ms": 0.063 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 839.93, + "duration_min_ms": 613.63, + "duration_max_ms": 882.61, + "duration_p50_ms": 879.22, + "duration_p99_ms": 882.61, + "duration_std_ms": 93.88, + "throughput_avg_mbps": 2164.47, + "throughput_min_mbps": 2030.33, + "throughput_max_mbps": 2920.32, + "ops_per_sec_avg": 154.6, + "latency_per_key_ms": 6.562 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.cpu new file mode 100644 index 0000000..eb56f82 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 42.8270161151886, "user_s": 50.381987, "sys_s": 8.497818, "max_rss_kb": 4444628} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.json new file mode 100644 index 0000000..9fe0ebe --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1885.98, + "duration_min_ms": 1593.02, + "duration_max_ms": 2072.71, + "duration_p50_ms": 1899.95, + "duration_p99_ms": 2072.71, + "duration_std_ms": 128.84, + "throughput_avg_mbps": 954.53, + "throughput_min_mbps": 864.57, + "throughput_max_mbps": 1124.91, + "ops_per_sec_avg": 68.18, + "latency_per_key_ms": 14.734 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 9.33, + "duration_min_ms": 4.22, + "duration_max_ms": 21.14, + "duration_p50_ms": 7.09, + "duration_p99_ms": 21.14, + "duration_std_ms": 5.39, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 17362.14, + "latency_per_key_ms": 0.073 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 799.76, + "duration_min_ms": 646.26, + "duration_max_ms": 866.17, + "duration_p50_ms": 785.01, + "duration_p99_ms": 866.17, + "duration_std_ms": 68.55, + "throughput_avg_mbps": 2257.09, + "throughput_min_mbps": 2068.89, + "throughput_max_mbps": 2772.86, + "ops_per_sec_avg": 161.22, + "latency_per_key_ms": 6.248 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.cpu new file mode 100644 index 0000000..4a76856 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.50635862350464, "user_s": 48.205717, "sys_s": 6.861522, "max_rss_kb": 4444268} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.json new file mode 100644 index 0000000..a64601f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1778.9, + "duration_min_ms": 1694.2, + "duration_max_ms": 1882.32, + "duration_p50_ms": 1763.36, + "duration_p99_ms": 1882.32, + "duration_std_ms": 56.83, + "throughput_avg_mbps": 1008.31, + "throughput_min_mbps": 952.02, + "throughput_max_mbps": 1057.73, + "ops_per_sec_avg": 72.02, + "latency_per_key_ms": 13.898 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 14.39, + "duration_min_ms": 6.64, + "duration_max_ms": 28.52, + "duration_p50_ms": 11.62, + "duration_p99_ms": 28.52, + "duration_std_ms": 7.39, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 11265.84, + "latency_per_key_ms": 0.112 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 812.24, + "duration_min_ms": 604.01, + "duration_max_ms": 872.33, + "duration_p50_ms": 861.17, + "duration_p99_ms": 872.33, + "duration_std_ms": 86.13, + "throughput_avg_mbps": 2233.52, + "throughput_min_mbps": 2054.27, + "throughput_max_mbps": 2966.86, + "ops_per_sec_avg": 159.54, + "latency_per_key_ms": 6.346 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.cpu new file mode 100644 index 0000000..5ed1103 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.54938101768494, "user_s": 14.194341, "sys_s": 5.777385, "max_rss_kb": 4427400} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.json new file mode 100644 index 0000000..0f1909a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":16,\"num_load_workers\":16}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1686.02, + "duration_min_ms": 1326.36, + "duration_max_ms": 1862.17, + "duration_p50_ms": 1705.08, + "duration_p99_ms": 1862.17, + "duration_std_ms": 160.9, + "throughput_avg_mbps": 1072.81, + "throughput_min_mbps": 962.32, + "throughput_max_mbps": 1351.07, + "ops_per_sec_avg": 76.63, + "latency_per_key_ms": 13.172 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.72, + "duration_min_ms": 0.59, + "duration_max_ms": 0.98, + "duration_p50_ms": 0.68, + "duration_p99_ms": 0.98, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 182024.73, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 849.35, + "duration_min_ms": 819.32, + "duration_max_ms": 862.65, + "duration_p50_ms": 850.98, + "duration_p99_ms": 862.65, + "duration_std_ms": 10.11, + "throughput_avg_mbps": 2110.13, + "throughput_min_mbps": 2077.31, + "throughput_max_mbps": 2187.19, + "ops_per_sec_avg": 150.72, + "latency_per_key_ms": 6.636 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.cpu new file mode 100644 index 0000000..f94f132 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.762086629867554, "user_s": 12.804451, "sys_s": 5.4914819999999995, "max_rss_kb": 4428252} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.json new file mode 100644 index 0000000..023dc96 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":16,\"num_load_workers\":16}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1729.61, + "duration_min_ms": 1553.83, + "duration_max_ms": 1844.83, + "duration_p50_ms": 1754.2, + "duration_p99_ms": 1844.83, + "duration_std_ms": 87.42, + "throughput_avg_mbps": 1038.65, + "throughput_min_mbps": 971.36, + "throughput_max_mbps": 1153.28, + "ops_per_sec_avg": 74.19, + "latency_per_key_ms": 13.513 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.64, + "duration_min_ms": 0.61, + "duration_max_ms": 0.69, + "duration_p50_ms": 0.64, + "duration_p99_ms": 0.69, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 199112.94, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 857.3, + "duration_min_ms": 840.01, + "duration_max_ms": 867.57, + "duration_p50_ms": 857.47, + "duration_p99_ms": 867.57, + "duration_std_ms": 7.93, + "throughput_avg_mbps": 2090.46, + "throughput_min_mbps": 2065.53, + "throughput_max_mbps": 2133.32, + "ops_per_sec_avg": 149.32, + "latency_per_key_ms": 6.698 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.cpu new file mode 100644 index 0000000..3c4b0cb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.21038794517517, "user_s": 14.562826, "sys_s": 5.129083, "max_rss_kb": 4427928} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.json new file mode 100644 index 0000000..3aed94b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":16,\"num_load_workers\":16}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1760.07, + "duration_min_ms": 1689.17, + "duration_max_ms": 1882.18, + "duration_p50_ms": 1736.29, + "duration_p99_ms": 1882.18, + "duration_std_ms": 60.49, + "throughput_avg_mbps": 1019.22, + "throughput_min_mbps": 952.09, + "throughput_max_mbps": 1060.87, + "ops_per_sec_avg": 72.8, + "latency_per_key_ms": 13.751 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.66, + "duration_min_ms": 0.62, + "duration_max_ms": 0.69, + "duration_p50_ms": 0.66, + "duration_p99_ms": 0.69, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 194023.09, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 848.8, + "duration_min_ms": 806.03, + "duration_max_ms": 863.44, + "duration_p50_ms": 851.25, + "duration_p99_ms": 863.44, + "duration_std_ms": 15.28, + "throughput_avg_mbps": 2111.86, + "throughput_min_mbps": 2075.41, + "throughput_max_mbps": 2223.25, + "ops_per_sec_avg": 150.85, + "latency_per_key_ms": 6.631 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.cpu new file mode 100644 index 0000000..4025ec4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.09267973899841, "user_s": 12.259621, "sys_s": 6.171332, "max_rss_kb": 4428696} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.json new file mode 100644 index 0000000..a7095a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1728.69, + "duration_min_ms": 1532.28, + "duration_max_ms": 1864.56, + "duration_p50_ms": 1725.38, + "duration_p99_ms": 1864.56, + "duration_std_ms": 97.91, + "throughput_avg_mbps": 1039.85, + "throughput_min_mbps": 961.09, + "throughput_max_mbps": 1169.5, + "ops_per_sec_avg": 74.27, + "latency_per_key_ms": 13.505 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.67, + "duration_min_ms": 0.65, + "duration_max_ms": 0.74, + "duration_p50_ms": 0.66, + "duration_p99_ms": 0.74, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 190387.93, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 860.91, + "duration_min_ms": 839.62, + "duration_max_ms": 864.24, + "duration_p50_ms": 862.59, + "duration_p99_ms": 864.24, + "duration_std_ms": 6.8, + "throughput_avg_mbps": 2081.65, + "throughput_min_mbps": 2073.49, + "throughput_max_mbps": 2134.29, + "ops_per_sec_avg": 148.69, + "latency_per_key_ms": 6.726 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.cpu new file mode 100644 index 0000000..7d6255f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.69519925117493, "user_s": 13.438353, "sys_s": 5.458585, "max_rss_kb": 4427796} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.json new file mode 100644 index 0000000..e445108 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1773.81, + "duration_min_ms": 1699.82, + "duration_max_ms": 1896.39, + "duration_p50_ms": 1769.54, + "duration_p99_ms": 1896.39, + "duration_std_ms": 59.58, + "throughput_avg_mbps": 1011.28, + "throughput_min_mbps": 944.96, + "throughput_max_mbps": 1054.23, + "ops_per_sec_avg": 72.23, + "latency_per_key_ms": 13.858 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.66, + "duration_min_ms": 0.62, + "duration_max_ms": 0.69, + "duration_p50_ms": 0.67, + "duration_p99_ms": 0.69, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 193643.58, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 850.03, + "duration_min_ms": 777.36, + "duration_max_ms": 864.05, + "duration_p50_ms": 852.48, + "duration_p99_ms": 864.05, + "duration_std_ms": 23.54, + "throughput_avg_mbps": 2109.75, + "throughput_min_mbps": 2073.96, + "throughput_max_mbps": 2305.22, + "ops_per_sec_avg": 150.7, + "latency_per_key_ms": 6.641 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.cpu new file mode 100644 index 0000000..7f71192 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.705289125442505, "user_s": 12.769223, "sys_s": 4.873692, "max_rss_kb": 4427864} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.json new file mode 100644 index 0000000..538236f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1793.88, + "duration_min_ms": 1711.73, + "duration_max_ms": 1897.05, + "duration_p50_ms": 1790.9, + "duration_p99_ms": 1897.05, + "duration_std_ms": 52.4, + "throughput_avg_mbps": 999.73, + "throughput_min_mbps": 944.63, + "throughput_max_mbps": 1046.9, + "ops_per_sec_avg": 71.41, + "latency_per_key_ms": 14.015 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.65, + "duration_min_ms": 0.63, + "duration_max_ms": 0.68, + "duration_p50_ms": 0.65, + "duration_p99_ms": 0.68, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 196720.51, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 860.57, + "duration_min_ms": 852.37, + "duration_max_ms": 864.74, + "duration_p50_ms": 862.12, + "duration_p99_ms": 864.74, + "duration_std_ms": 4.59, + "throughput_avg_mbps": 2082.4, + "throughput_min_mbps": 2072.31, + "throughput_max_mbps": 2102.37, + "ops_per_sec_avg": 148.74, + "latency_per_key_ms": 6.723 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.cpu new file mode 100644 index 0000000..0132b5d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.255492210388184, "user_s": 13.637513, "sys_s": 5.059978, "max_rss_kb": 4427920} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.json new file mode 100644 index 0000000..fa19385 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1685.01, + "duration_min_ms": 1434.47, + "duration_max_ms": 1947.2, + "duration_p50_ms": 1671.8, + "duration_p99_ms": 1947.2, + "duration_std_ms": 140.14, + "throughput_avg_mbps": 1070.35, + "throughput_min_mbps": 920.3, + "throughput_max_mbps": 1249.24, + "ops_per_sec_avg": 76.45, + "latency_per_key_ms": 13.164 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.74, + "duration_min_ms": 0.68, + "duration_max_ms": 0.95, + "duration_p50_ms": 0.72, + "duration_p99_ms": 0.95, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 173786.87, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 850.7, + "duration_min_ms": 807.04, + "duration_max_ms": 864.93, + "duration_p50_ms": 850.91, + "duration_p99_ms": 864.93, + "duration_std_ms": 14.84, + "throughput_avg_mbps": 2107.12, + "throughput_min_mbps": 2071.85, + "throughput_max_mbps": 2220.45, + "ops_per_sec_avg": 150.51, + "latency_per_key_ms": 6.646 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.cpu new file mode 100644 index 0000000..ea0b062 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 39.05069541931152, "user_s": 13.094542, "sys_s": 6.522712, "max_rss_kb": 4426560} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.json new file mode 100644 index 0000000..cb0fec2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1591.81, + "duration_min_ms": 1401.79, + "duration_max_ms": 1758.86, + "duration_p50_ms": 1541.21, + "duration_p99_ms": 1758.86, + "duration_std_ms": 124.19, + "throughput_avg_mbps": 1132.14, + "throughput_min_mbps": 1018.84, + "throughput_max_mbps": 1278.37, + "ops_per_sec_avg": 80.87, + "latency_per_key_ms": 12.436 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.61, + "duration_min_ms": 0.57, + "duration_max_ms": 0.65, + "duration_p50_ms": 0.6, + "duration_p99_ms": 0.65, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 211626.66, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 856.92, + "duration_min_ms": 851.77, + "duration_max_ms": 864.93, + "duration_p50_ms": 854.02, + "duration_p99_ms": 864.93, + "duration_std_ms": 5.18, + "throughput_avg_mbps": 2091.28, + "throughput_min_mbps": 2071.83, + "throughput_max_mbps": 2103.85, + "ops_per_sec_avg": 149.38, + "latency_per_key_ms": 6.695 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.cpu new file mode 100644 index 0000000..601b867 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 38.153517723083496, "user_s": 13.845154, "sys_s": 4.502753, "max_rss_kb": 4427320} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.json new file mode 100644 index 0000000..32a793b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/raw_block_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1562.61, + "duration_min_ms": 1310.38, + "duration_max_ms": 1913.05, + "duration_p50_ms": 1419.28, + "duration_p99_ms": 1913.05, + "duration_std_ms": 227.96, + "throughput_avg_mbps": 1169.03, + "throughput_min_mbps": 936.73, + "throughput_max_mbps": 1367.54, + "ops_per_sec_avg": 83.5, + "latency_per_key_ms": 12.208 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.52, + "duration_min_ms": 0.51, + "duration_max_ms": 0.54, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.54, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 245050.74, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 853.0, + "duration_min_ms": 850.02, + "duration_max_ms": 855.16, + "duration_p50_ms": 853.07, + "duration_p99_ms": 855.16, + "duration_std_ms": 1.37, + "throughput_avg_mbps": 2100.82, + "throughput_min_mbps": 2095.52, + "throughput_max_mbps": 2108.17, + "ops_per_sec_avg": 150.06, + "latency_per_key_ms": 6.664 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.cpu new file mode 100644 index 0000000..394a32e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.64728021621704, "user_s": 19.140337, "sys_s": 7.957721, "max_rss_kb": 4364764} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.json new file mode 100644 index 0000000..0fe26ee --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1759.54, + "duration_min_ms": 1524.56, + "duration_max_ms": 1907.91, + "duration_p50_ms": 1759.41, + "duration_p99_ms": 1907.91, + "duration_std_ms": 99.48, + "throughput_avg_mbps": 1021.62, + "throughput_min_mbps": 939.25, + "throughput_max_mbps": 1175.42, + "ops_per_sec_avg": 72.97, + "latency_per_key_ms": 13.746 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.72, + "duration_min_ms": 2.11, + "duration_max_ms": 8.32, + "duration_p50_ms": 3.0, + "duration_p99_ms": 8.32, + "duration_std_ms": 2.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 41671.15, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 859.69, + "duration_min_ms": 850.71, + "duration_max_ms": 867.89, + "duration_p50_ms": 855.9, + "duration_p99_ms": 867.89, + "duration_std_ms": 6.68, + "throughput_avg_mbps": 2084.6, + "throughput_min_mbps": 2064.78, + "throughput_max_mbps": 2106.47, + "ops_per_sec_avg": 148.9, + "latency_per_key_ms": 6.716 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.cpu new file mode 100644 index 0000000..b25c711 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 42.5741822719574, "user_s": 19.533634, "sys_s": 7.345299, "max_rss_kb": 4365860} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.json new file mode 100644 index 0000000..6718f95 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1818.26, + "duration_min_ms": 1682.18, + "duration_max_ms": 1980.42, + "duration_p50_ms": 1810.84, + "duration_p99_ms": 1980.42, + "duration_std_ms": 92.75, + "throughput_avg_mbps": 987.88, + "throughput_min_mbps": 904.86, + "throughput_max_mbps": 1065.29, + "ops_per_sec_avg": 70.56, + "latency_per_key_ms": 14.205 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.76, + "duration_min_ms": 2.5, + "duration_max_ms": 7.44, + "duration_p50_ms": 3.07, + "duration_p99_ms": 7.44, + "duration_std_ms": 1.6, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 38024.84, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 856.79, + "duration_min_ms": 853.14, + "duration_max_ms": 866.45, + "duration_p50_ms": 855.85, + "duration_p99_ms": 866.45, + "duration_std_ms": 3.33, + "throughput_avg_mbps": 2091.56, + "throughput_min_mbps": 2068.22, + "throughput_max_mbps": 2100.48, + "ops_per_sec_avg": 149.4, + "latency_per_key_ms": 6.694 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.cpu new file mode 100644 index 0000000..df65fb7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.18001413345337, "user_s": 17.693928, "sys_s": 7.774027, "max_rss_kb": 4365112} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.json new file mode 100644 index 0000000..51d9038 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1621.42, + "duration_min_ms": 1394.35, + "duration_max_ms": 1834.22, + "duration_p50_ms": 1628.31, + "duration_p99_ms": 1834.22, + "duration_std_ms": 123.98, + "throughput_avg_mbps": 1111.17, + "throughput_min_mbps": 976.98, + "throughput_max_mbps": 1285.19, + "ops_per_sec_avg": 79.37, + "latency_per_key_ms": 12.667 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.84, + "duration_min_ms": 2.51, + "duration_max_ms": 6.63, + "duration_p50_ms": 3.11, + "duration_p99_ms": 6.63, + "duration_std_ms": 1.53, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 37466.1, + "latency_per_key_ms": 0.03 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 867.01, + "duration_min_ms": 864.24, + "duration_max_ms": 869.48, + "duration_p50_ms": 867.26, + "duration_p99_ms": 869.48, + "duration_std_ms": 1.48, + "throughput_avg_mbps": 2066.89, + "throughput_min_mbps": 2061.0, + "throughput_max_mbps": 2073.51, + "ops_per_sec_avg": 147.63, + "latency_per_key_ms": 6.773 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.cpu new file mode 100644 index 0000000..94a9f7c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 42.301634550094604, "user_s": 19.306088, "sys_s": 6.535405, "max_rss_kb": 4366020} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.json new file mode 100644 index 0000000..0c51853 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1801.12, + "duration_min_ms": 1658.49, + "duration_max_ms": 1923.34, + "duration_p50_ms": 1777.86, + "duration_p99_ms": 1923.34, + "duration_std_ms": 73.24, + "throughput_avg_mbps": 996.45, + "throughput_min_mbps": 931.71, + "throughput_max_mbps": 1080.5, + "ops_per_sec_avg": 71.17, + "latency_per_key_ms": 14.071 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.66, + "duration_min_ms": 2.7, + "duration_max_ms": 5.25, + "duration_p50_ms": 3.69, + "duration_p99_ms": 5.25, + "duration_std_ms": 0.65, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 35990.3, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 857.8, + "duration_min_ms": 852.61, + "duration_max_ms": 868.55, + "duration_p50_ms": 856.67, + "duration_p99_ms": 868.55, + "duration_std_ms": 5.05, + "throughput_avg_mbps": 2089.14, + "throughput_min_mbps": 2063.21, + "throughput_max_mbps": 2101.78, + "ops_per_sec_avg": 149.22, + "latency_per_key_ms": 6.702 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.cpu new file mode 100644 index 0000000..2b86072 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.53530311584473, "user_s": 17.593998, "sys_s": 6.928396, "max_rss_kb": 4365264} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.json new file mode 100644 index 0000000..2326706 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1887.93, + "duration_min_ms": 1806.83, + "duration_max_ms": 2003.42, + "duration_p50_ms": 1866.2, + "duration_p99_ms": 2003.42, + "duration_std_ms": 65.91, + "throughput_avg_mbps": 950.23, + "throughput_min_mbps": 894.47, + "throughput_max_mbps": 991.79, + "ops_per_sec_avg": 67.87, + "latency_per_key_ms": 14.749 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 4.35, + "duration_min_ms": 1.5, + "duration_max_ms": 8.44, + "duration_p50_ms": 3.99, + "duration_p99_ms": 8.44, + "duration_std_ms": 2.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 37832.41, + "latency_per_key_ms": 0.034 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 859.32, + "duration_min_ms": 775.7, + "duration_max_ms": 869.77, + "duration_p50_ms": 866.7, + "duration_p99_ms": 869.77, + "duration_std_ms": 26.38, + "throughput_avg_mbps": 2087.34, + "throughput_min_mbps": 2060.32, + "throughput_max_mbps": 2310.19, + "ops_per_sec_avg": 149.1, + "latency_per_key_ms": 6.713 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.cpu new file mode 100644 index 0000000..fff2fe8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.149505615234375, "user_s": 18.278853, "sys_s": 6.011777, "max_rss_kb": 4365328} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.json new file mode 100644 index 0000000..9215afa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1883.79, + "duration_min_ms": 1782.17, + "duration_max_ms": 2006.85, + "duration_p50_ms": 1860.21, + "duration_p99_ms": 2006.85, + "duration_std_ms": 73.53, + "throughput_avg_mbps": 952.59, + "throughput_min_mbps": 892.94, + "throughput_max_mbps": 1005.51, + "ops_per_sec_avg": 68.04, + "latency_per_key_ms": 14.717 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 4.64, + "duration_min_ms": 3.04, + "duration_max_ms": 8.63, + "duration_p50_ms": 4.31, + "duration_p99_ms": 8.63, + "duration_std_ms": 1.52, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 29824.04, + "latency_per_key_ms": 0.036 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 862.11, + "duration_min_ms": 823.59, + "duration_max_ms": 867.91, + "duration_p50_ms": 866.51, + "duration_p99_ms": 867.91, + "duration_std_ms": 12.61, + "throughput_avg_mbps": 2079.05, + "throughput_min_mbps": 2064.72, + "throughput_max_mbps": 2175.84, + "ops_per_sec_avg": 148.5, + "latency_per_key_ms": 6.735 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.cpu new file mode 100644 index 0000000..bb4d040 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.64785933494568, "user_s": 18.952578, "sys_s": 6.55959, "max_rss_kb": 4365084} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.json new file mode 100644 index 0000000..c9520eb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1752.28, + "duration_min_ms": 1519.35, + "duration_max_ms": 1950.36, + "duration_p50_ms": 1754.96, + "duration_p99_ms": 1950.36, + "duration_std_ms": 121.34, + "throughput_avg_mbps": 1027.21, + "throughput_min_mbps": 918.8, + "throughput_max_mbps": 1179.45, + "ops_per_sec_avg": 73.37, + "latency_per_key_ms": 13.69 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.3, + "duration_min_ms": 2.17, + "duration_max_ms": 4.86, + "duration_p50_ms": 2.98, + "duration_p99_ms": 4.86, + "duration_std_ms": 0.99, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 41893.91, + "latency_per_key_ms": 0.026 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 839.89, + "duration_min_ms": 659.74, + "duration_max_ms": 860.21, + "duration_p50_ms": 856.12, + "duration_p99_ms": 860.21, + "duration_std_ms": 56.78, + "throughput_avg_mbps": 2144.77, + "throughput_min_mbps": 2083.22, + "throughput_max_mbps": 2716.24, + "ops_per_sec_avg": 153.2, + "latency_per_key_ms": 6.562 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.cpu new file mode 100644 index 0000000..6716e69 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.83227586746216, "user_s": 19.6246, "sys_s": 7.2292629999999996, "max_rss_kb": 4365052} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.json new file mode 100644 index 0000000..81e7618 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1692.2, + "duration_min_ms": 1569.58, + "duration_max_ms": 1810.37, + "duration_p50_ms": 1664.5, + "duration_p99_ms": 1810.37, + "duration_std_ms": 77.7, + "throughput_avg_mbps": 1061.02, + "throughput_min_mbps": 989.85, + "throughput_max_mbps": 1141.71, + "ops_per_sec_avg": 75.79, + "latency_per_key_ms": 13.22 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.16, + "duration_min_ms": 2.09, + "duration_max_ms": 5.74, + "duration_p50_ms": 2.76, + "duration_p99_ms": 5.74, + "duration_std_ms": 1.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 44365.45, + "latency_per_key_ms": 0.025 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 835.77, + "duration_min_ms": 600.17, + "duration_max_ms": 858.21, + "duration_p50_ms": 857.0, + "duration_p99_ms": 858.21, + "duration_std_ms": 74.2, + "throughput_avg_mbps": 2165.16, + "throughput_min_mbps": 2088.07, + "throughput_max_mbps": 2985.82, + "ops_per_sec_avg": 154.65, + "latency_per_key_ms": 6.529 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.cpu new file mode 100644 index 0000000..4d7efd2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 35.068700551986694, "user_s": 17.202982, "sys_s": 6.196342, "max_rss_kb": 4365000} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.json new file mode 100644 index 0000000..9298ddd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if16/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 1287.71, + "duration_min_ms": 1224.03, + "duration_max_ms": 1363.37, + "duration_p50_ms": 1285.65, + "duration_p99_ms": 1363.37, + "duration_std_ms": 44.56, + "throughput_avg_mbps": 1393.14, + "throughput_min_mbps": 1314.39, + "throughput_max_mbps": 1464.02, + "ops_per_sec_avg": 99.51, + "latency_per_key_ms": 10.06 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 4.25, + "duration_min_ms": 2.46, + "duration_max_ms": 10.09, + "duration_p50_ms": 3.25, + "duration_p99_ms": 10.09, + "duration_std_ms": 2.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 34838.07, + "latency_per_key_ms": 0.033 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 861.08, + "duration_min_ms": 797.37, + "duration_max_ms": 868.86, + "duration_p50_ms": 866.69, + "duration_p99_ms": 868.86, + "duration_std_ms": 20.11, + "throughput_avg_mbps": 2082.22, + "throughput_min_mbps": 2062.47, + "throughput_max_mbps": 2247.38, + "ops_per_sec_avg": 148.73, + "latency_per_key_ms": 6.727 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.cpu new file mode 100644 index 0000000..42ee273 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 36.32168364524841, "user_s": 46.252323, "sys_s": 5.31855, "max_rss_kb": 1693316} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.json new file mode 100644 index 0000000..54f759b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 415.87, + "duration_min_ms": 329.15, + "duration_max_ms": 553.7, + "duration_p50_ms": 410.36, + "duration_p99_ms": 553.7, + "duration_std_ms": 69.68, + "throughput_avg_mbps": 1106.34, + "throughput_min_mbps": 809.1, + "throughput_max_mbps": 1361.07, + "ops_per_sec_avg": 79.02, + "latency_per_key_ms": 12.996 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 6.44, + "duration_min_ms": 1.36, + "duration_max_ms": 13.74, + "duration_p50_ms": 6.87, + "duration_p99_ms": 13.74, + "duration_std_ms": 3.69, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 7847.91, + "latency_per_key_ms": 0.201 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 197.6, + "duration_min_ms": 155.15, + "duration_max_ms": 239.91, + "duration_p50_ms": 214.24, + "duration_p99_ms": 239.91, + "duration_std_ms": 25.87, + "throughput_avg_mbps": 2308.31, + "throughput_min_mbps": 1867.34, + "throughput_max_mbps": 2887.52, + "ops_per_sec_avg": 164.88, + "latency_per_key_ms": 6.175 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.cpu new file mode 100644 index 0000000..337aba2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 35.27138423919678, "user_s": 45.128032, "sys_s": 5.135555, "max_rss_kb": 1693064} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.json new file mode 100644 index 0000000..915e708 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 396.45, + "duration_min_ms": 343.65, + "duration_max_ms": 467.93, + "duration_p50_ms": 396.71, + "duration_p99_ms": 467.93, + "duration_std_ms": 33.86, + "throughput_avg_mbps": 1138.15, + "throughput_min_mbps": 957.41, + "throughput_max_mbps": 1303.65, + "ops_per_sec_avg": 81.3, + "latency_per_key_ms": 12.389 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 4.13, + "duration_min_ms": 1.29, + "duration_max_ms": 10.72, + "duration_p50_ms": 3.09, + "duration_p99_ms": 10.72, + "duration_std_ms": 2.92, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12128.55, + "latency_per_key_ms": 0.129 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 198.91, + "duration_min_ms": 149.83, + "duration_max_ms": 219.51, + "duration_p50_ms": 213.46, + "duration_p99_ms": 219.51, + "duration_std_ms": 24.09, + "throughput_avg_mbps": 2289.69, + "throughput_min_mbps": 2040.93, + "throughput_max_mbps": 2990.04, + "ops_per_sec_avg": 163.55, + "latency_per_key_ms": 6.216 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.cpu new file mode 100644 index 0000000..71f6b6a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 38.97083020210266, "user_s": 47.548976, "sys_s": 4.986448, "max_rss_kb": 1692088} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.json new file mode 100644 index 0000000..1888bc0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 474.26, + "duration_min_ms": 372.85, + "duration_max_ms": 581.81, + "duration_p50_ms": 472.02, + "duration_p99_ms": 581.81, + "duration_std_ms": 56.48, + "throughput_avg_mbps": 957.82, + "throughput_min_mbps": 770.02, + "throughput_max_mbps": 1201.56, + "ops_per_sec_avg": 68.42, + "latency_per_key_ms": 14.821 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 4.59, + "duration_min_ms": 1.36, + "duration_max_ms": 12.18, + "duration_p50_ms": 3.98, + "duration_p99_ms": 12.18, + "duration_std_ms": 2.85, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 10081.87, + "latency_per_key_ms": 0.143 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 197.88, + "duration_min_ms": 154.92, + "duration_max_ms": 218.68, + "duration_p50_ms": 210.12, + "duration_p99_ms": 218.68, + "duration_std_ms": 21.2, + "throughput_avg_mbps": 2291.55, + "throughput_min_mbps": 2048.68, + "throughput_max_mbps": 2891.78, + "ops_per_sec_avg": 163.68, + "latency_per_key_ms": 6.184 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.cpu new file mode 100644 index 0000000..8df203c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 34.89203763008118, "user_s": 13.226058, "sys_s": 2.705763, "max_rss_kb": 1674480} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.json new file mode 100644 index 0000000..f451a4f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 400.42, + "duration_min_ms": 327.67, + "duration_max_ms": 516.68, + "duration_p50_ms": 374.28, + "duration_p99_ms": 516.68, + "duration_std_ms": 50.56, + "throughput_avg_mbps": 1135.39, + "throughput_min_mbps": 867.07, + "throughput_max_mbps": 1367.22, + "ops_per_sec_avg": 81.1, + "latency_per_key_ms": 12.513 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.23, + "duration_max_ms": 0.26, + "duration_p50_ms": 0.25, + "duration_p99_ms": 0.26, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 127979.92, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 199.75, + "duration_min_ms": 89.38, + "duration_max_ms": 217.87, + "duration_p50_ms": 215.04, + "duration_p99_ms": 217.87, + "duration_std_ms": 40.78, + "throughput_avg_mbps": 2425.29, + "throughput_min_mbps": 2056.3, + "throughput_max_mbps": 5012.37, + "ops_per_sec_avg": 173.23, + "latency_per_key_ms": 6.242 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.cpu new file mode 100644 index 0000000..19380b0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 37.1402473449707, "user_s": 15.439544, "sys_s": 2.655612, "max_rss_kb": 1674080} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.json new file mode 100644 index 0000000..0b92b8b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 445.17, + "duration_min_ms": 365.24, + "duration_max_ms": 508.27, + "duration_p50_ms": 443.61, + "duration_p99_ms": 508.27, + "duration_std_ms": 30.09, + "throughput_avg_mbps": 1010.96, + "throughput_min_mbps": 881.43, + "throughput_max_mbps": 1226.57, + "ops_per_sec_avg": 72.21, + "latency_per_key_ms": 13.912 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.21, + "duration_min_ms": 0.19, + "duration_max_ms": 0.23, + "duration_p50_ms": 0.21, + "duration_p99_ms": 0.23, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 152378.57, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 195.12, + "duration_min_ms": 100.08, + "duration_max_ms": 214.19, + "duration_p50_ms": 211.38, + "duration_p99_ms": 214.19, + "duration_std_ms": 38.06, + "throughput_avg_mbps": 2442.13, + "throughput_min_mbps": 2091.61, + "throughput_max_mbps": 4476.6, + "ops_per_sec_avg": 174.44, + "latency_per_key_ms": 6.097 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.cpu new file mode 100644 index 0000000..3805f15 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 36.27268028259277, "user_s": 14.452355, "sys_s": 2.784343, "max_rss_kb": 1673948} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.json new file mode 100644 index 0000000..dc26901 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/raw_block_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/vdc\",\"slot_bytes\":14684160,\"capacity_bytes\":429496729600,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 428.54, + "duration_min_ms": 368.0, + "duration_max_ms": 499.26, + "duration_p50_ms": 422.17, + "duration_p99_ms": 499.26, + "duration_std_ms": 29.83, + "throughput_avg_mbps": 1050.34, + "throughput_min_mbps": 897.32, + "throughput_max_mbps": 1217.38, + "ops_per_sec_avg": 75.02, + "latency_per_key_ms": 13.392 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 0.2, + "duration_min_ms": 0.18, + "duration_max_ms": 0.22, + "duration_p50_ms": 0.2, + "duration_p99_ms": 0.22, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 161201.3, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 197.38, + "duration_min_ms": 94.32, + "duration_max_ms": 215.16, + "duration_p50_ms": 212.45, + "duration_p99_ms": 215.16, + "duration_std_ms": 38.47, + "throughput_avg_mbps": 2424.87, + "throughput_min_mbps": 2082.14, + "throughput_max_mbps": 4749.75, + "ops_per_sec_avg": 173.21, + "latency_per_key_ms": 6.168 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.cpu new file mode 100644 index 0000000..c31d643 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 35.278841972351074, "user_s": 17.159217, "sys_s": 3.766524, "max_rss_kb": 1611604} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.json new file mode 100644 index 0000000..d011910 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 392.41, + "duration_min_ms": 336.83, + "duration_max_ms": 461.42, + "duration_p50_ms": 387.46, + "duration_p99_ms": 461.42, + "duration_std_ms": 25.93, + "throughput_avg_mbps": 1146.45, + "throughput_min_mbps": 970.92, + "throughput_max_mbps": 1330.04, + "ops_per_sec_avg": 81.89, + "latency_per_key_ms": 12.263 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 3.0, + "duration_min_ms": 0.62, + "duration_max_ms": 9.95, + "duration_p50_ms": 2.01, + "duration_p99_ms": 9.95, + "duration_std_ms": 2.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15293.86, + "latency_per_key_ms": 0.094 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 200.38, + "duration_min_ms": 106.16, + "duration_max_ms": 220.16, + "duration_p50_ms": 216.34, + "duration_p99_ms": 220.16, + "duration_std_ms": 38.31, + "throughput_avg_mbps": 2371.76, + "throughput_min_mbps": 2034.85, + "throughput_max_mbps": 4220.06, + "ops_per_sec_avg": 169.41, + "latency_per_key_ms": 6.262 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.cpu new file mode 100644 index 0000000..4ee3abf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 36.53308653831482, "user_s": 18.731498, "sys_s": 3.702435, "max_rss_kb": 1612496} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.json new file mode 100644 index 0000000..6e09a99 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 419.85, + "duration_min_ms": 297.03, + "duration_max_ms": 484.79, + "duration_p50_ms": 424.63, + "duration_p99_ms": 484.79, + "duration_std_ms": 39.81, + "throughput_avg_mbps": 1077.54, + "throughput_min_mbps": 924.12, + "throughput_max_mbps": 1508.28, + "ops_per_sec_avg": 76.97, + "latency_per_key_ms": 13.12 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 2.83, + "duration_min_ms": 0.9, + "duration_max_ms": 9.34, + "duration_p50_ms": 2.32, + "duration_p99_ms": 9.34, + "duration_std_ms": 1.72, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15049.96, + "latency_per_key_ms": 0.088 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 198.11, + "duration_min_ms": 110.93, + "duration_max_ms": 216.31, + "duration_p50_ms": 214.47, + "duration_p99_ms": 216.31, + "duration_std_ms": 36.39, + "throughput_avg_mbps": 2377.56, + "throughput_min_mbps": 2071.15, + "throughput_max_mbps": 4038.55, + "ops_per_sec_avg": 169.83, + "latency_per_key_ms": 6.191 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.cpu new file mode 100644 index 0000000..c2bd329 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 36.64380478858948, "user_s": 17.804562, "sys_s": 3.63362, "max_rss_kb": 1612760} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.json new file mode 100644 index 0000000..c5bbe4a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d1_if4/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 48, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 425.76, + "duration_min_ms": 347.54, + "duration_max_ms": 520.37, + "duration_p50_ms": 418.09, + "duration_p99_ms": 520.37, + "duration_std_ms": 44.82, + "throughput_avg_mbps": 1063.42, + "throughput_min_mbps": 860.93, + "throughput_max_mbps": 1289.06, + "ops_per_sec_avg": 75.96, + "latency_per_key_ms": 13.305 + }, + "op_1": { + "operation": "Lookup", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 0, + "duration_avg_ms": 1.97, + "duration_min_ms": 0.57, + "duration_max_ms": 6.12, + "duration_p50_ms": 1.39, + "duration_p99_ms": 6.12, + "duration_std_ms": 1.37, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 23434.04, + "latency_per_key_ms": 0.062 + }, + "op_2": { + "operation": "Load", + "rounds": 48, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 1536, + "total_success": 1536, + "duration_avg_ms": 198.62, + "duration_min_ms": 109.3, + "duration_max_ms": 216.48, + "duration_p50_ms": 214.58, + "duration_p99_ms": 216.48, + "duration_std_ms": 37.0, + "throughput_avg_mbps": 2377.49, + "throughput_min_mbps": 2069.44, + "throughput_max_mbps": 4098.64, + "ops_per_sec_avg": 169.82, + "latency_per_key_ms": 6.207 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.cpu new file mode 100644 index 0000000..7a38559 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.66908383369446, "user_s": 89.398231, "sys_s": 14.616061, "max_rss_kb": 4480936} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.json new file mode 100644 index 0000000..6256276 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1209.08, + "duration_min_ms": 1122.22, + "duration_max_ms": 1392.85, + "duration_p50_ms": 1191.87, + "duration_p99_ms": 1392.85, + "duration_std_ms": 68.56, + "throughput_avg_mbps": 1486.53, + "throughput_min_mbps": 1286.58, + "throughput_max_mbps": 1596.84, + "ops_per_sec_avg": 106.18, + "latency_per_key_ms": 9.446 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 10.35, + "duration_min_ms": 5.4, + "duration_max_ms": 25.39, + "duration_p50_ms": 7.98, + "duration_p99_ms": 25.39, + "duration_std_ms": 5.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15015.07, + "latency_per_key_ms": 0.081 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 612.99, + "duration_min_ms": 495.56, + "duration_max_ms": 758.62, + "duration_p50_ms": 610.03, + "duration_p99_ms": 758.62, + "duration_std_ms": 61.7, + "throughput_avg_mbps": 2952.45, + "throughput_min_mbps": 2362.18, + "throughput_max_mbps": 3616.11, + "ops_per_sec_avg": 210.89, + "latency_per_key_ms": 4.789 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.cpu new file mode 100644 index 0000000..cc0e0cf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.661386251449585, "user_s": 84.273632, "sys_s": 15.947255, "max_rss_kb": 4480132} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.json new file mode 100644 index 0000000..bec7561 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1135.07, + "duration_min_ms": 978.75, + "duration_max_ms": 1346.6, + "duration_p50_ms": 1131.9, + "duration_p99_ms": 1346.6, + "duration_std_ms": 93.88, + "throughput_avg_mbps": 1589.01, + "throughput_min_mbps": 1330.76, + "throughput_max_mbps": 1830.91, + "ops_per_sec_avg": 113.5, + "latency_per_key_ms": 8.868 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 9.86, + "duration_min_ms": 4.11, + "duration_max_ms": 26.98, + "duration_p50_ms": 9.02, + "duration_p99_ms": 26.98, + "duration_std_ms": 5.15, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15792.83, + "latency_per_key_ms": 0.077 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 584.18, + "duration_min_ms": 499.15, + "duration_max_ms": 813.48, + "duration_p50_ms": 556.4, + "duration_p99_ms": 813.48, + "duration_std_ms": 73.28, + "throughput_avg_mbps": 3107.81, + "throughput_min_mbps": 2202.89, + "throughput_max_mbps": 3590.07, + "ops_per_sec_avg": 221.99, + "latency_per_key_ms": 4.564 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.cpu new file mode 100644 index 0000000..6561805 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.790122747421265, "user_s": 90.280407, "sys_s": 12.63887, "max_rss_kb": 4481828} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.json new file mode 100644 index 0000000..ba51fcd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1162.51, + "duration_min_ms": 1053.0, + "duration_max_ms": 1260.78, + "duration_p50_ms": 1169.69, + "duration_p99_ms": 1260.78, + "duration_std_ms": 55.79, + "throughput_avg_mbps": 1544.97, + "throughput_min_mbps": 1421.34, + "throughput_max_mbps": 1701.8, + "ops_per_sec_avg": 110.36, + "latency_per_key_ms": 9.082 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 15.3, + "duration_min_ms": 6.17, + "duration_max_ms": 33.28, + "duration_p50_ms": 10.29, + "duration_p99_ms": 33.28, + "duration_std_ms": 9.63, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 11762.93, + "latency_per_key_ms": 0.12 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 672.68, + "duration_min_ms": 545.67, + "duration_max_ms": 780.75, + "duration_p50_ms": 687.05, + "duration_p99_ms": 780.75, + "duration_std_ms": 68.86, + "throughput_avg_mbps": 2692.24, + "throughput_min_mbps": 2295.22, + "throughput_max_mbps": 3284.05, + "ops_per_sec_avg": 192.3, + "latency_per_key_ms": 5.255 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.cpu new file mode 100644 index 0000000..ad41b54 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.83521485328674, "user_s": 93.710942, "sys_s": 17.114123, "max_rss_kb": 4550776} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.json new file mode 100644 index 0000000..d8d02fd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1178.97, + "duration_min_ms": 1033.84, + "duration_max_ms": 1372.18, + "duration_p50_ms": 1183.39, + "duration_p99_ms": 1372.18, + "duration_std_ms": 78.51, + "throughput_avg_mbps": 1526.42, + "throughput_min_mbps": 1305.96, + "throughput_max_mbps": 1733.34, + "ops_per_sec_avg": 109.03, + "latency_per_key_ms": 9.211 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 10.58, + "duration_min_ms": 4.14, + "duration_max_ms": 27.67, + "duration_p50_ms": 8.1, + "duration_p99_ms": 27.67, + "duration_std_ms": 6.23, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15497.05, + "latency_per_key_ms": 0.083 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 653.65, + "duration_min_ms": 524.93, + "duration_max_ms": 770.35, + "duration_p50_ms": 661.94, + "duration_p99_ms": 770.35, + "duration_std_ms": 71.85, + "throughput_avg_mbps": 2774.37, + "throughput_min_mbps": 2326.22, + "throughput_max_mbps": 3413.79, + "ops_per_sec_avg": 198.17, + "latency_per_key_ms": 5.107 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.cpu new file mode 100644 index 0000000..9827b92 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 52.91021943092346, "user_s": 90.402909, "sys_s": 18.551378, "max_rss_kb": 4550400} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.json new file mode 100644 index 0000000..063ac62 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1206.28, + "duration_min_ms": 1076.0, + "duration_max_ms": 1349.43, + "duration_p50_ms": 1209.66, + "duration_p99_ms": 1349.43, + "duration_std_ms": 83.15, + "throughput_avg_mbps": 1492.43, + "throughput_min_mbps": 1327.97, + "throughput_max_mbps": 1665.42, + "ops_per_sec_avg": 106.6, + "latency_per_key_ms": 9.424 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 11.5, + "duration_min_ms": 4.34, + "duration_max_ms": 28.46, + "duration_p50_ms": 9.03, + "duration_p99_ms": 28.46, + "duration_std_ms": 6.98, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15291.59, + "latency_per_key_ms": 0.09 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 593.49, + "duration_min_ms": 542.64, + "duration_max_ms": 662.14, + "duration_p50_ms": 582.07, + "duration_p99_ms": 662.14, + "duration_std_ms": 38.79, + "throughput_avg_mbps": 3031.59, + "throughput_min_mbps": 2706.39, + "throughput_max_mbps": 3302.37, + "ops_per_sec_avg": 216.54, + "latency_per_key_ms": 4.637 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.cpu new file mode 100644 index 0000000..827d1d9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 59.33621835708618, "user_s": 103.077626, "sys_s": 19.847591, "max_rss_kb": 4549600} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.json new file mode 100644 index 0000000..a3c7726 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/python_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1301.29, + "duration_min_ms": 1160.12, + "duration_max_ms": 1464.88, + "duration_p50_ms": 1305.49, + "duration_p99_ms": 1464.88, + "duration_std_ms": 63.88, + "throughput_avg_mbps": 1380.3, + "throughput_min_mbps": 1223.31, + "throughput_max_mbps": 1544.66, + "ops_per_sec_avg": 98.59, + "latency_per_key_ms": 10.166 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 14.39, + "duration_min_ms": 4.39, + "duration_max_ms": 29.74, + "duration_p50_ms": 12.64, + "duration_p99_ms": 29.74, + "duration_std_ms": 7.77, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12253.86, + "latency_per_key_ms": 0.112 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 731.58, + "duration_min_ms": 666.77, + "duration_max_ms": 843.64, + "duration_p50_ms": 732.52, + "duration_p99_ms": 843.64, + "duration_std_ms": 38.6, + "throughput_avg_mbps": 2455.89, + "throughput_min_mbps": 2124.14, + "throughput_max_mbps": 2687.57, + "ops_per_sec_avg": 175.42, + "latency_per_key_ms": 5.715 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.cpu new file mode 100644 index 0000000..351d392 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 45.261650800704956, "user_s": 26.910118, "sys_s": 8.544815, "max_rss_kb": 4366436} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.json new file mode 100644 index 0000000..7aab01c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1056.79, + "duration_min_ms": 955.65, + "duration_max_ms": 1124.36, + "duration_p50_ms": 1064.08, + "duration_p99_ms": 1124.36, + "duration_std_ms": 42.24, + "throughput_avg_mbps": 1698.37, + "throughput_min_mbps": 1593.79, + "throughput_max_mbps": 1875.16, + "ops_per_sec_avg": 121.31, + "latency_per_key_ms": 8.256 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 4.33, + "duration_min_ms": 2.46, + "duration_max_ms": 8.18, + "duration_p50_ms": 3.83, + "duration_p99_ms": 8.18, + "duration_std_ms": 1.53, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 33049.76, + "latency_per_key_ms": 0.034 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 450.78, + "duration_min_ms": 346.32, + "duration_max_ms": 489.27, + "duration_p50_ms": 475.09, + "duration_p99_ms": 489.27, + "duration_std_ms": 53.11, + "throughput_avg_mbps": 4037.34, + "throughput_min_mbps": 3662.64, + "throughput_max_mbps": 5174.43, + "ops_per_sec_avg": 288.38, + "latency_per_key_ms": 3.522 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.cpu new file mode 100644 index 0000000..3ae6778 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.49896550178528, "user_s": 26.446687, "sys_s": 7.416867, "max_rss_kb": 4364520} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.json new file mode 100644 index 0000000..43e85a7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 981.79, + "duration_min_ms": 923.84, + "duration_max_ms": 1074.25, + "duration_p50_ms": 974.92, + "duration_p99_ms": 1074.25, + "duration_std_ms": 34.89, + "throughput_avg_mbps": 1827.39, + "throughput_min_mbps": 1668.15, + "throughput_max_mbps": 1939.73, + "ops_per_sec_avg": 130.53, + "latency_per_key_ms": 7.67 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 6.42, + "duration_min_ms": 3.0, + "duration_max_ms": 10.61, + "duration_p50_ms": 6.39, + "duration_p99_ms": 10.61, + "duration_std_ms": 2.31, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 23029.69, + "latency_per_key_ms": 0.05 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 460.75, + "duration_min_ms": 268.19, + "duration_max_ms": 486.99, + "duration_p50_ms": 484.22, + "duration_p99_ms": 486.99, + "duration_std_ms": 60.65, + "throughput_avg_mbps": 3988.51, + "throughput_min_mbps": 3679.76, + "throughput_max_mbps": 6681.79, + "ops_per_sec_avg": 284.89, + "latency_per_key_ms": 3.6 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.cpu new file mode 100644 index 0000000..661a055 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 46.32153654098511, "user_s": 27.988428, "sys_s": 7.9165849999999995, "max_rss_kb": 4366868} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.json new file mode 100644 index 0000000..70f9d09 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1096.56, + "duration_min_ms": 1004.41, + "duration_max_ms": 1207.74, + "duration_p50_ms": 1087.04, + "duration_p99_ms": 1207.74, + "duration_std_ms": 55.95, + "throughput_avg_mbps": 1638.27, + "throughput_min_mbps": 1483.77, + "throughput_max_mbps": 1784.13, + "ops_per_sec_avg": 117.02, + "latency_per_key_ms": 8.567 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 5.43, + "duration_min_ms": 2.25, + "duration_max_ms": 11.32, + "duration_p50_ms": 4.35, + "duration_p99_ms": 11.32, + "duration_std_ms": 2.71, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 29462.81, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 448.75, + "duration_min_ms": 351.6, + "duration_max_ms": 487.74, + "duration_p50_ms": 475.51, + "duration_p99_ms": 487.74, + "duration_std_ms": 52.3, + "throughput_avg_mbps": 4053.54, + "throughput_min_mbps": 3674.06, + "throughput_max_mbps": 5096.71, + "ops_per_sec_avg": 289.54, + "latency_per_key_ms": 3.506 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.cpu new file mode 100644 index 0000000..a337f02 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.72915053367615, "user_s": 28.798677, "sys_s": 7.4539539999999995, "max_rss_kb": 4366676} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.json new file mode 100644 index 0000000..b98dcb9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1029.68, + "duration_min_ms": 930.89, + "duration_max_ms": 1144.83, + "duration_p50_ms": 1035.38, + "duration_p99_ms": 1144.83, + "duration_std_ms": 50.53, + "throughput_avg_mbps": 1744.4, + "throughput_min_mbps": 1565.3, + "throughput_max_mbps": 1925.05, + "ops_per_sec_avg": 124.6, + "latency_per_key_ms": 8.044 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 3.69, + "duration_min_ms": 1.93, + "duration_max_ms": 6.06, + "duration_p50_ms": 3.09, + "duration_p99_ms": 6.06, + "duration_std_ms": 1.35, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 39327.53, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 454.44, + "duration_min_ms": 266.58, + "duration_max_ms": 485.41, + "duration_p50_ms": 474.45, + "duration_p99_ms": 485.41, + "duration_std_ms": 60.25, + "throughput_avg_mbps": 4049.0, + "throughput_min_mbps": 3691.76, + "throughput_max_mbps": 6722.09, + "ops_per_sec_avg": 289.21, + "latency_per_key_ms": 3.55 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.cpu new file mode 100644 index 0000000..8cac210 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.74383878707886, "user_s": 28.979575, "sys_s": 8.967516, "max_rss_kb": 4365852} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.json new file mode 100644 index 0000000..13c2823 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 984.42, + "duration_min_ms": 893.09, + "duration_max_ms": 1124.64, + "duration_p50_ms": 965.28, + "duration_p99_ms": 1124.64, + "duration_std_ms": 56.11, + "throughput_avg_mbps": 1825.84, + "throughput_min_mbps": 1593.4, + "throughput_max_mbps": 2006.51, + "ops_per_sec_avg": 130.42, + "latency_per_key_ms": 7.691 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 3.72, + "duration_min_ms": 2.01, + "duration_max_ms": 6.59, + "duration_p50_ms": 2.69, + "duration_p99_ms": 6.59, + "duration_std_ms": 1.67, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 40919.44, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 452.16, + "duration_min_ms": 282.05, + "duration_max_ms": 488.06, + "duration_p50_ms": 475.4, + "duration_p99_ms": 488.06, + "duration_std_ms": 64.73, + "throughput_avg_mbps": 4080.54, + "throughput_min_mbps": 3671.71, + "throughput_max_mbps": 6353.54, + "ops_per_sec_avg": 291.47, + "latency_per_key_ms": 3.532 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.cpu new file mode 100644 index 0000000..d1b9495 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.63622069358826, "user_s": 26.777803, "sys_s": 9.377753, "max_rss_kb": 4366484} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.json new file mode 100644 index 0000000..d87fa32 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 915.43, + "duration_min_ms": 852.38, + "duration_max_ms": 1082.14, + "duration_p50_ms": 905.88, + "duration_p99_ms": 1082.14, + "duration_std_ms": 55.08, + "throughput_avg_mbps": 1963.84, + "throughput_min_mbps": 1655.97, + "throughput_max_mbps": 2102.35, + "ops_per_sec_avg": 140.27, + "latency_per_key_ms": 7.152 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 4.43, + "duration_min_ms": 2.89, + "duration_max_ms": 9.32, + "duration_p50_ms": 3.89, + "duration_p99_ms": 9.32, + "duration_std_ms": 1.6, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 31543.35, + "latency_per_key_ms": 0.035 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 459.0, + "duration_min_ms": 281.39, + "duration_max_ms": 488.49, + "duration_p50_ms": 484.0, + "duration_p99_ms": 488.49, + "duration_std_ms": 64.9, + "throughput_avg_mbps": 4016.79, + "throughput_min_mbps": 3668.46, + "throughput_max_mbps": 6368.31, + "ops_per_sec_avg": 286.91, + "latency_per_key_ms": 3.586 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.cpu new file mode 100644 index 0000000..c0d5559 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.274354457855225, "user_s": 28.457334, "sys_s": 7.645872, "max_rss_kb": 4369060} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.json new file mode 100644 index 0000000..dcfb832 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1011.55, + "duration_min_ms": 895.99, + "duration_max_ms": 1116.77, + "duration_p50_ms": 1034.52, + "duration_p99_ms": 1116.77, + "duration_std_ms": 64.87, + "throughput_avg_mbps": 1778.73, + "throughput_min_mbps": 1604.63, + "throughput_max_mbps": 2000.03, + "ops_per_sec_avg": 127.05, + "latency_per_key_ms": 7.903 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 2.91, + "duration_min_ms": 1.83, + "duration_max_ms": 5.11, + "duration_p50_ms": 2.62, + "duration_p99_ms": 5.11, + "duration_std_ms": 0.93, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47889.75, + "latency_per_key_ms": 0.023 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 455.29, + "duration_min_ms": 287.1, + "duration_max_ms": 489.28, + "duration_p50_ms": 476.02, + "duration_p99_ms": 489.28, + "duration_std_ms": 60.85, + "throughput_avg_mbps": 4033.89, + "throughput_min_mbps": 3662.53, + "throughput_max_mbps": 6241.73, + "ops_per_sec_avg": 288.14, + "latency_per_key_ms": 3.557 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.cpu new file mode 100644 index 0000000..2039565 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.228880882263184, "user_s": 28.632794, "sys_s": 8.650901, "max_rss_kb": 4368024} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.json new file mode 100644 index 0000000..7317bac --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 963.85, + "duration_min_ms": 874.81, + "duration_max_ms": 1067.15, + "duration_p50_ms": 950.66, + "duration_p99_ms": 1067.15, + "duration_std_ms": 53.04, + "throughput_avg_mbps": 1864.54, + "throughput_min_mbps": 1679.23, + "throughput_max_mbps": 2048.45, + "ops_per_sec_avg": 133.18, + "latency_per_key_ms": 7.53 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 4.92, + "duration_min_ms": 3.19, + "duration_max_ms": 11.75, + "duration_p50_ms": 4.2, + "duration_p99_ms": 11.75, + "duration_std_ms": 1.96, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 28736.35, + "latency_per_key_ms": 0.038 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 454.82, + "duration_min_ms": 285.58, + "duration_max_ms": 488.37, + "duration_p50_ms": 475.36, + "duration_p99_ms": 488.37, + "duration_std_ms": 62.89, + "throughput_avg_mbps": 4046.95, + "throughput_min_mbps": 3669.32, + "throughput_max_mbps": 6275.06, + "ops_per_sec_avg": 289.07, + "latency_per_key_ms": 3.553 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.cpu new file mode 100644 index 0000000..edb58be --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.36937069892883, "user_s": 29.40961, "sys_s": 9.077532, "max_rss_kb": 4368868} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.json new file mode 100644 index 0000000..66fe0f5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d2_if16/rust_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 974.05, + "duration_min_ms": 911.66, + "duration_max_ms": 1033.71, + "duration_p50_ms": 971.81, + "duration_p99_ms": 1033.71, + "duration_std_ms": 34.18, + "throughput_avg_mbps": 1841.9, + "throughput_min_mbps": 1733.56, + "throughput_max_mbps": 1965.63, + "ops_per_sec_avg": 131.56, + "latency_per_key_ms": 7.61 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 4.8, + "duration_min_ms": 2.46, + "duration_max_ms": 9.02, + "duration_p50_ms": 3.92, + "duration_p99_ms": 9.02, + "duration_std_ms": 2.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 31418.35, + "latency_per_key_ms": 0.038 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 453.36, + "duration_min_ms": 286.32, + "duration_max_ms": 477.68, + "duration_p50_ms": 475.19, + "duration_p99_ms": 477.68, + "duration_std_ms": 60.0, + "throughput_avg_mbps": 4049.99, + "throughput_min_mbps": 3751.5, + "throughput_max_mbps": 6258.65, + "ops_per_sec_avg": 289.28, + "latency_per_key_ms": 3.542 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.cpu new file mode 100644 index 0000000..ee06713 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 86.63465428352356, "user_s": 151.181641, "sys_s": 27.485064, "max_rss_kb": 4688312} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.json new file mode 100644 index 0000000..cd7b1dd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1240.92, + "duration_min_ms": 1063.02, + "duration_max_ms": 1400.58, + "duration_p50_ms": 1227.42, + "duration_p99_ms": 1400.58, + "duration_std_ms": 89.98, + "throughput_avg_mbps": 1451.61, + "throughput_min_mbps": 1279.47, + "throughput_max_mbps": 1685.77, + "ops_per_sec_avg": 103.69, + "latency_per_key_ms": 9.695 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 13.71, + "duration_min_ms": 4.36, + "duration_max_ms": 38.15, + "duration_p50_ms": 11.48, + "duration_p99_ms": 38.15, + "duration_std_ms": 7.98, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12425.15, + "latency_per_key_ms": 0.107 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 653.41, + "duration_min_ms": 568.09, + "duration_max_ms": 813.32, + "duration_p50_ms": 654.86, + "duration_p99_ms": 813.32, + "duration_std_ms": 49.84, + "throughput_avg_mbps": 2757.58, + "throughput_min_mbps": 2203.32, + "throughput_max_mbps": 3154.41, + "ops_per_sec_avg": 196.97, + "latency_per_key_ms": 5.105 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.cpu new file mode 100644 index 0000000..b5d5272 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 87.74729251861572, "user_s": 158.804045, "sys_s": 28.028029, "max_rss_kb": 4688816} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.json new file mode 100644 index 0000000..75de3e8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1209.9, + "duration_min_ms": 955.1, + "duration_max_ms": 1432.85, + "duration_p50_ms": 1210.45, + "duration_p99_ms": 1432.85, + "duration_std_ms": 121.25, + "throughput_avg_mbps": 1496.0, + "throughput_min_mbps": 1250.65, + "throughput_max_mbps": 1876.25, + "ops_per_sec_avg": 106.86, + "latency_per_key_ms": 9.452 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 11.54, + "duration_min_ms": 4.05, + "duration_max_ms": 28.81, + "duration_p50_ms": 10.68, + "duration_p99_ms": 28.81, + "duration_std_ms": 5.95, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 14345.02, + "latency_per_key_ms": 0.09 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 703.36, + "duration_min_ms": 562.84, + "duration_max_ms": 816.2, + "duration_p50_ms": 710.89, + "duration_p99_ms": 816.2, + "duration_std_ms": 60.91, + "throughput_avg_mbps": 2567.27, + "throughput_min_mbps": 2195.55, + "throughput_max_mbps": 3183.85, + "ops_per_sec_avg": 183.38, + "latency_per_key_ms": 5.495 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.cpu new file mode 100644 index 0000000..41782f1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 77.56937289237976, "user_s": 133.726237, "sys_s": 25.275641, "max_rss_kb": 4688896} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.json new file mode 100644 index 0000000..b3b43d6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1128.18, + "duration_min_ms": 1008.76, + "duration_max_ms": 1251.16, + "duration_p50_ms": 1126.66, + "duration_p99_ms": 1251.16, + "duration_std_ms": 61.69, + "throughput_avg_mbps": 1592.99, + "throughput_min_mbps": 1432.27, + "throughput_max_mbps": 1776.44, + "ops_per_sec_avg": 113.79, + "latency_per_key_ms": 8.814 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 14.74, + "duration_min_ms": 4.36, + "duration_max_ms": 32.11, + "duration_p50_ms": 12.92, + "duration_p99_ms": 32.11, + "duration_std_ms": 7.63, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 11787.73, + "latency_per_key_ms": 0.115 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 546.11, + "duration_min_ms": 502.48, + "duration_max_ms": 646.22, + "duration_p50_ms": 544.34, + "duration_p99_ms": 646.22, + "duration_std_ms": 24.95, + "throughput_avg_mbps": 3287.68, + "throughput_min_mbps": 2773.06, + "throughput_max_mbps": 3566.32, + "ops_per_sec_avg": 234.83, + "latency_per_key_ms": 4.266 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.cpu new file mode 100644 index 0000000..2c1728b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 76.24438285827637, "user_s": 128.938228, "sys_s": 13.93439, "max_rss_kb": 4446536} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.json new file mode 100644 index 0000000..69d9245 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 971.17, + "duration_min_ms": 880.96, + "duration_max_ms": 1088.09, + "duration_p50_ms": 971.24, + "duration_p99_ms": 1088.09, + "duration_std_ms": 50.41, + "throughput_avg_mbps": 1850.02, + "throughput_min_mbps": 1646.92, + "throughput_max_mbps": 2034.15, + "ops_per_sec_avg": 132.14, + "latency_per_key_ms": 7.587 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 13.07, + "duration_min_ms": 3.96, + "duration_max_ms": 37.01, + "duration_p50_ms": 8.66, + "duration_p99_ms": 37.01, + "duration_std_ms": 8.51, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 14236.94, + "latency_per_key_ms": 0.102 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 682.6, + "duration_min_ms": 551.24, + "duration_max_ms": 797.43, + "duration_p50_ms": 678.47, + "duration_p99_ms": 797.43, + "duration_std_ms": 60.57, + "throughput_avg_mbps": 2645.91, + "throughput_min_mbps": 2247.22, + "throughput_max_mbps": 3250.87, + "ops_per_sec_avg": 188.99, + "latency_per_key_ms": 5.333 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.cpu new file mode 100644 index 0000000..7d4f737 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 83.38641309738159, "user_s": 132.61106, "sys_s": 14.777939, "max_rss_kb": 4445380} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.json new file mode 100644 index 0000000..09ec1b6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1053.43, + "duration_min_ms": 940.95, + "duration_max_ms": 1216.32, + "duration_p50_ms": 1045.46, + "duration_p99_ms": 1216.32, + "duration_std_ms": 62.4, + "throughput_avg_mbps": 1706.84, + "throughput_min_mbps": 1473.3, + "throughput_max_mbps": 1904.47, + "ops_per_sec_avg": 121.92, + "latency_per_key_ms": 8.23 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 8.34, + "duration_min_ms": 3.99, + "duration_max_ms": 21.01, + "duration_p50_ms": 7.08, + "duration_p99_ms": 21.01, + "duration_std_ms": 3.58, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 17566.33, + "latency_per_key_ms": 0.065 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 779.95, + "duration_min_ms": 662.98, + "duration_max_ms": 919.47, + "duration_p50_ms": 774.83, + "duration_p99_ms": 919.47, + "duration_std_ms": 57.61, + "throughput_avg_mbps": 2309.85, + "throughput_min_mbps": 1948.95, + "throughput_max_mbps": 2702.96, + "ops_per_sec_avg": 164.99, + "latency_per_key_ms": 6.093 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.cpu new file mode 100644 index 0000000..9f24f31 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 79.73952603340149, "user_s": 136.400463, "sys_s": 15.341423, "max_rss_kb": 4445732} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.json new file mode 100644 index 0000000..5657f05 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1009.41, + "duration_min_ms": 934.17, + "duration_max_ms": 1112.25, + "duration_p50_ms": 1003.43, + "duration_p99_ms": 1112.25, + "duration_std_ms": 35.82, + "throughput_avg_mbps": 1777.46, + "throughput_min_mbps": 1611.14, + "throughput_max_mbps": 1918.29, + "ops_per_sec_avg": 126.96, + "latency_per_key_ms": 7.886 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 13.29, + "duration_min_ms": 4.69, + "duration_max_ms": 40.35, + "duration_p50_ms": 9.86, + "duration_p99_ms": 40.35, + "duration_std_ms": 9.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13796.38, + "latency_per_key_ms": 0.104 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 717.46, + "duration_min_ms": 563.39, + "duration_max_ms": 875.63, + "duration_p50_ms": 717.94, + "duration_p99_ms": 875.63, + "duration_std_ms": 74.91, + "throughput_avg_mbps": 2525.91, + "throughput_min_mbps": 2046.53, + "throughput_max_mbps": 3180.74, + "ops_per_sec_avg": 180.42, + "latency_per_key_ms": 5.605 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.cpu new file mode 100644 index 0000000..d8bb9ad --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 64.86759448051453, "user_s": 41.106023, "sys_s": 11.609479, "max_rss_kb": 4372404} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.json new file mode 100644 index 0000000..0b3fd74 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1069.73, + "duration_min_ms": 952.69, + "duration_max_ms": 1216.83, + "duration_p50_ms": 1070.68, + "duration_p99_ms": 1216.83, + "duration_std_ms": 65.93, + "throughput_avg_mbps": 1681.41, + "throughput_min_mbps": 1472.68, + "throughput_max_mbps": 1880.99, + "ops_per_sec_avg": 120.1, + "latency_per_key_ms": 8.357 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 4.25, + "duration_min_ms": 2.78, + "duration_max_ms": 9.05, + "duration_p50_ms": 3.89, + "duration_p99_ms": 9.05, + "duration_std_ms": 1.17, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 31811.24, + "latency_per_key_ms": 0.033 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 321.34, + "duration_min_ms": 305.76, + "duration_max_ms": 358.83, + "duration_p50_ms": 317.8, + "duration_p99_ms": 358.83, + "duration_std_ms": 11.54, + "throughput_avg_mbps": 5583.28, + "throughput_min_mbps": 4993.97, + "throughput_max_mbps": 5860.83, + "ops_per_sec_avg": 398.81, + "latency_per_key_ms": 2.51 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.cpu new file mode 100644 index 0000000..affb55c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 66.79268383979797, "user_s": 43.60469, "sys_s": 10.755044999999999, "max_rss_kb": 4372920} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.json new file mode 100644 index 0000000..1d3f49b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1119.53, + "duration_min_ms": 991.87, + "duration_max_ms": 1293.55, + "duration_p50_ms": 1115.98, + "duration_p99_ms": 1293.55, + "duration_std_ms": 67.98, + "throughput_avg_mbps": 1606.22, + "throughput_min_mbps": 1385.34, + "throughput_max_mbps": 1806.68, + "ops_per_sec_avg": 114.73, + "latency_per_key_ms": 8.746 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 4.37, + "duration_min_ms": 1.66, + "duration_max_ms": 11.59, + "duration_p50_ms": 4.17, + "duration_p99_ms": 11.59, + "duration_std_ms": 2.21, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 36783.58, + "latency_per_key_ms": 0.034 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 313.31, + "duration_min_ms": 296.84, + "duration_max_ms": 356.89, + "duration_p50_ms": 311.56, + "duration_p99_ms": 356.89, + "duration_std_ms": 12.3, + "throughput_avg_mbps": 5727.67, + "throughput_min_mbps": 5021.13, + "throughput_max_mbps": 6037.01, + "ops_per_sec_avg": 409.12, + "latency_per_key_ms": 2.448 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.cpu new file mode 100644 index 0000000..b8af041 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 63.63934516906738, "user_s": 41.572231, "sys_s": 10.395916, "max_rss_kb": 4372868} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.json new file mode 100644 index 0000000..de27768 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w128-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1074.43, + "duration_min_ms": 926.93, + "duration_max_ms": 1224.61, + "duration_p50_ms": 1070.39, + "duration_p99_ms": 1224.61, + "duration_std_ms": 70.41, + "throughput_avg_mbps": 1674.97, + "throughput_min_mbps": 1463.33, + "throughput_max_mbps": 1933.27, + "ops_per_sec_avg": 119.64, + "latency_per_key_ms": 8.394 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 2.55, + "duration_min_ms": 1.66, + "duration_max_ms": 5.09, + "duration_p50_ms": 2.2, + "duration_p99_ms": 5.09, + "duration_std_ms": 0.93, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 55309.46, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 278.29, + "duration_min_ms": 254.38, + "duration_max_ms": 353.98, + "duration_p50_ms": 267.44, + "duration_p99_ms": 353.98, + "duration_std_ms": 25.67, + "throughput_avg_mbps": 6485.09, + "throughput_min_mbps": 5062.43, + "throughput_max_mbps": 7044.56, + "ops_per_sec_avg": 463.22, + "latency_per_key_ms": 2.174 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.cpu new file mode 100644 index 0000000..70eef4f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 59.57746076583862, "user_s": 40.26267, "sys_s": 11.090103, "max_rss_kb": 4366552} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.json new file mode 100644 index 0000000..0319e94 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 919.71, + "duration_min_ms": 868.74, + "duration_max_ms": 993.02, + "duration_p50_ms": 907.32, + "duration_p99_ms": 993.02, + "duration_std_ms": 35.07, + "throughput_avg_mbps": 1951.14, + "throughput_min_mbps": 1804.59, + "throughput_max_mbps": 2062.75, + "ops_per_sec_avg": 139.37, + "latency_per_key_ms": 7.185 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 3.9, + "duration_min_ms": 2.18, + "duration_max_ms": 7.54, + "duration_p50_ms": 3.55, + "duration_p99_ms": 7.54, + "duration_std_ms": 1.17, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 35289.18, + "latency_per_key_ms": 0.03 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 325.93, + "duration_min_ms": 265.5, + "duration_max_ms": 366.15, + "duration_p50_ms": 332.89, + "duration_p99_ms": 366.15, + "duration_std_ms": 24.1, + "throughput_avg_mbps": 5529.19, + "throughput_min_mbps": 4894.2, + "throughput_max_mbps": 6749.59, + "ops_per_sec_avg": 394.94, + "latency_per_key_ms": 2.546 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.cpu new file mode 100644 index 0000000..b99a178 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 60.809086084365845, "user_s": 42.43382, "sys_s": 9.29282, "max_rss_kb": 4367044} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.json new file mode 100644 index 0000000..142c34f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 990.9, + "duration_min_ms": 917.01, + "duration_max_ms": 1082.16, + "duration_p50_ms": 991.18, + "duration_p99_ms": 1082.16, + "duration_std_ms": 38.54, + "throughput_avg_mbps": 1811.13, + "throughput_min_mbps": 1655.94, + "throughput_max_mbps": 1954.17, + "ops_per_sec_avg": 129.37, + "latency_per_key_ms": 7.741 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 6.27, + "duration_min_ms": 3.26, + "duration_max_ms": 13.1, + "duration_p50_ms": 5.65, + "duration_p99_ms": 13.1, + "duration_std_ms": 2.53, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 23351.58, + "latency_per_key_ms": 0.049 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 292.24, + "duration_min_ms": 248.79, + "duration_max_ms": 348.28, + "duration_p50_ms": 286.28, + "duration_p99_ms": 348.28, + "duration_std_ms": 25.19, + "throughput_avg_mbps": 6174.79, + "throughput_min_mbps": 5145.22, + "throughput_max_mbps": 7202.89, + "ops_per_sec_avg": 441.06, + "latency_per_key_ms": 2.283 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.cpu new file mode 100644 index 0000000..839794b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 61.297321796417236, "user_s": 39.203163, "sys_s": 9.721157999999999, "max_rss_kb": 4365648} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.json new file mode 100644 index 0000000..dcf9dea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 996.66, + "duration_min_ms": 902.97, + "duration_max_ms": 1148.5, + "duration_p50_ms": 980.19, + "duration_p99_ms": 1148.5, + "duration_std_ms": 58.29, + "throughput_avg_mbps": 1803.81, + "throughput_min_mbps": 1560.29, + "throughput_max_mbps": 1984.57, + "ops_per_sec_avg": 128.84, + "latency_per_key_ms": 7.786 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 4.43, + "duration_min_ms": 2.36, + "duration_max_ms": 7.89, + "duration_p50_ms": 3.98, + "duration_p99_ms": 7.89, + "duration_std_ms": 1.44, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 31583.15, + "latency_per_key_ms": 0.035 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 301.71, + "duration_min_ms": 250.28, + "duration_max_ms": 370.2, + "duration_p50_ms": 297.55, + "duration_p99_ms": 370.2, + "duration_std_ms": 35.08, + "throughput_avg_mbps": 6017.71, + "throughput_min_mbps": 4840.67, + "throughput_max_mbps": 7160.03, + "ops_per_sec_avg": 429.84, + "latency_per_key_ms": 2.357 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.cpu new file mode 100644 index 0000000..d68da5c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 61.491060972213745, "user_s": 41.78398, "sys_s": 11.501141, "max_rss_kb": 4365656} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.json new file mode 100644 index 0000000..1ef2a22 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1016.08, + "duration_min_ms": 930.18, + "duration_max_ms": 1178.71, + "duration_p50_ms": 1016.22, + "duration_p99_ms": 1178.71, + "duration_std_ms": 49.7, + "throughput_avg_mbps": 1767.6, + "throughput_min_mbps": 1520.31, + "throughput_max_mbps": 1926.5, + "ops_per_sec_avg": 126.26, + "latency_per_key_ms": 7.938 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 5.39, + "duration_min_ms": 3.07, + "duration_max_ms": 13.63, + "duration_p50_ms": 4.52, + "duration_p99_ms": 13.63, + "duration_std_ms": 2.25, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 27164.17, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 279.49, + "duration_min_ms": 267.74, + "duration_max_ms": 313.11, + "duration_p50_ms": 276.65, + "duration_p99_ms": 313.11, + "duration_std_ms": 9.22, + "throughput_avg_mbps": 6418.03, + "throughput_min_mbps": 5723.22, + "throughput_max_mbps": 6693.04, + "ops_per_sec_avg": 458.43, + "latency_per_key_ms": 2.184 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.cpu new file mode 100644 index 0000000..fcd7c4a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 64.02695393562317, "user_s": 39.994751, "sys_s": 10.656058999999999, "max_rss_kb": 4366428} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.json new file mode 100644 index 0000000..dfb9da4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1057.32, + "duration_min_ms": 967.14, + "duration_max_ms": 1202.56, + "duration_p50_ms": 1041.1, + "duration_p99_ms": 1202.56, + "duration_std_ms": 56.94, + "throughput_avg_mbps": 1699.53, + "throughput_min_mbps": 1490.15, + "throughput_max_mbps": 1852.89, + "ops_per_sec_avg": 121.4, + "latency_per_key_ms": 8.26 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 4.23, + "duration_min_ms": 2.53, + "duration_max_ms": 6.8, + "duration_p50_ms": 3.91, + "duration_p99_ms": 6.8, + "duration_std_ms": 1.13, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 32424.16, + "latency_per_key_ms": 0.033 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 305.66, + "duration_min_ms": 290.6, + "duration_max_ms": 333.09, + "duration_p50_ms": 302.34, + "duration_p99_ms": 333.09, + "duration_std_ms": 10.3, + "throughput_avg_mbps": 5868.98, + "throughput_min_mbps": 5379.86, + "throughput_max_mbps": 6166.48, + "ops_per_sec_avg": 419.21, + "latency_per_key_ms": 2.388 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.cpu new file mode 100644 index 0000000..f6b6762 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 60.510215282440186, "user_s": 40.839399, "sys_s": 10.282669, "max_rss_kb": 4366128} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.json new file mode 100644 index 0000000..b238d44 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1026.68, + "duration_min_ms": 900.38, + "duration_max_ms": 1106.99, + "duration_p50_ms": 1028.01, + "duration_p99_ms": 1106.99, + "duration_std_ms": 41.88, + "throughput_avg_mbps": 1748.36, + "throughput_min_mbps": 1618.8, + "throughput_max_mbps": 1990.28, + "ops_per_sec_avg": 124.88, + "latency_per_key_ms": 8.021 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 5.39, + "duration_min_ms": 2.97, + "duration_max_ms": 9.58, + "duration_p50_ms": 4.41, + "duration_p99_ms": 9.58, + "duration_std_ms": 1.96, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 26798.11, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 250.03, + "duration_min_ms": 229.07, + "duration_max_ms": 282.19, + "duration_p50_ms": 249.81, + "duration_p99_ms": 282.19, + "duration_std_ms": 9.45, + "throughput_avg_mbps": 7176.65, + "throughput_min_mbps": 6350.32, + "throughput_max_mbps": 7823.02, + "ops_per_sec_avg": 512.62, + "latency_per_key_ms": 1.953 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.cpu new file mode 100644 index 0000000..6199c82 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 66.05163669586182, "user_s": 44.322136, "sys_s": 10.007752, "max_rss_kb": 4367948} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.json new file mode 100644 index 0000000..c8de0ce --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1080.2, + "duration_min_ms": 971.21, + "duration_max_ms": 1228.03, + "duration_p50_ms": 1065.55, + "duration_p99_ms": 1228.03, + "duration_std_ms": 57.56, + "throughput_avg_mbps": 1663.4, + "throughput_min_mbps": 1459.24, + "throughput_max_mbps": 1845.12, + "ops_per_sec_avg": 118.81, + "latency_per_key_ms": 8.439 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 3.41, + "duration_min_ms": 2.11, + "duration_max_ms": 7.69, + "duration_p50_ms": 3.05, + "duration_p99_ms": 7.69, + "duration_std_ms": 1.16, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 40788.63, + "latency_per_key_ms": 0.027 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 318.35, + "duration_min_ms": 295.92, + "duration_max_ms": 376.56, + "duration_p50_ms": 314.63, + "duration_p99_ms": 376.56, + "duration_std_ms": 16.63, + "throughput_avg_mbps": 5643.2, + "throughput_min_mbps": 4758.82, + "throughput_max_mbps": 6055.71, + "ops_per_sec_avg": 403.09, + "latency_per_key_ms": 2.487 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.cpu new file mode 100644 index 0000000..a161a02 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 66.34757256507874, "user_s": 41.776997, "sys_s": 10.450956, "max_rss_kb": 4369148} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.json new file mode 100644 index 0000000..4e1772d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1110.1, + "duration_min_ms": 997.36, + "duration_max_ms": 1251.28, + "duration_p50_ms": 1110.27, + "duration_p99_ms": 1251.28, + "duration_std_ms": 61.27, + "throughput_avg_mbps": 1619.08, + "throughput_min_mbps": 1432.13, + "throughput_max_mbps": 1796.74, + "ops_per_sec_avg": 115.65, + "latency_per_key_ms": 8.673 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 4.65, + "duration_min_ms": 2.77, + "duration_max_ms": 7.71, + "duration_p50_ms": 3.96, + "duration_p99_ms": 7.71, + "duration_std_ms": 1.42, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 30034.32, + "latency_per_key_ms": 0.036 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 307.2, + "duration_min_ms": 292.77, + "duration_max_ms": 334.79, + "duration_p50_ms": 306.26, + "duration_p99_ms": 334.79, + "duration_std_ms": 9.57, + "throughput_avg_mbps": 5838.79, + "throughput_min_mbps": 5352.59, + "throughput_max_mbps": 6120.74, + "ops_per_sec_avg": 417.06, + "latency_per_key_ms": 2.4 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.cpu new file mode 100644 index 0000000..917c1e7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 62.12707877159119, "user_s": 42.562069, "sys_s": 10.482996, "max_rss_kb": 4367784} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.json new file mode 100644 index 0000000..1d1e783 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/d4_if16/rust_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 40, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 1057.5, + "duration_min_ms": 898.43, + "duration_max_ms": 1274.76, + "duration_p50_ms": 1030.81, + "duration_p99_ms": 1274.76, + "duration_std_ms": 83.67, + "throughput_avg_mbps": 1704.36, + "throughput_min_mbps": 1405.76, + "throughput_max_mbps": 1994.59, + "ops_per_sec_avg": 121.74, + "latency_per_key_ms": 8.262 + }, + "op_1": { + "operation": "Lookup", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 0, + "duration_avg_ms": 3.42, + "duration_min_ms": 1.71, + "duration_max_ms": 5.69, + "duration_p50_ms": 3.22, + "duration_p99_ms": 5.69, + "duration_std_ms": 0.95, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 40418.06, + "latency_per_key_ms": 0.027 + }, + "op_2": { + "operation": "Load", + "rounds": 40, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 5120, + "total_success": 5120, + "duration_avg_ms": 257.32, + "duration_min_ms": 244.14, + "duration_max_ms": 287.09, + "duration_p50_ms": 254.84, + "duration_p99_ms": 287.09, + "duration_std_ms": 11.72, + "throughput_avg_mbps": 6977.65, + "throughput_min_mbps": 6241.97, + "throughput_max_mbps": 7340.2, + "ops_per_sec_avg": 498.4, + "latency_per_key_ms": 2.01 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.cpu new file mode 100644 index 0000000..d046672 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.39470410346985, "user_s": 144.428189, "sys_s": 121.194317, "max_rss_kb": 4416196} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.json new file mode 100644 index 0000000..6f8833f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 528.33, + "duration_min_ms": 382.41, + "duration_max_ms": 644.5, + "duration_p50_ms": 544.43, + "duration_p99_ms": 644.5, + "duration_std_ms": 62.55, + "throughput_avg_mbps": 3444.45, + "throughput_min_mbps": 2780.44, + "throughput_max_mbps": 4686.03, + "ops_per_sec_avg": 246.03, + "latency_per_key_ms": 4.128 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 9.76, + "duration_min_ms": 5.33, + "duration_max_ms": 33.88, + "duration_p50_ms": 8.2, + "duration_p99_ms": 33.88, + "duration_std_ms": 5.37, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 15421.51, + "latency_per_key_ms": 0.076 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 293.02, + "duration_min_ms": 224.8, + "duration_max_ms": 348.38, + "duration_p50_ms": 287.84, + "duration_p99_ms": 348.38, + "duration_std_ms": 24.11, + "throughput_avg_mbps": 6157.7, + "throughput_min_mbps": 5143.79, + "throughput_max_mbps": 7971.69, + "ops_per_sec_avg": 439.84, + "latency_per_key_ms": 2.289 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.cpu new file mode 100644 index 0000000..28d7530 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.9564688205719, "user_s": 144.765377, "sys_s": 120.600772, "max_rss_kb": 4416388} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.json new file mode 100644 index 0000000..e84a0d5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 547.1, + "duration_min_ms": 443.38, + "duration_max_ms": 692.76, + "duration_p50_ms": 542.83, + "duration_p99_ms": 692.76, + "duration_std_ms": 53.15, + "throughput_avg_mbps": 3305.99, + "throughput_min_mbps": 2586.74, + "throughput_max_mbps": 4041.65, + "ops_per_sec_avg": 236.14, + "latency_per_key_ms": 4.274 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 12.15, + "duration_min_ms": 5.49, + "duration_max_ms": 24.42, + "duration_p50_ms": 10.94, + "duration_p99_ms": 24.42, + "duration_std_ms": 5.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12694.04, + "latency_per_key_ms": 0.095 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 287.67, + "duration_min_ms": 249.4, + "duration_max_ms": 351.92, + "duration_p50_ms": 286.92, + "duration_p99_ms": 351.92, + "duration_std_ms": 22.76, + "throughput_avg_mbps": 6266.96, + "throughput_min_mbps": 5092.14, + "throughput_max_mbps": 7185.22, + "ops_per_sec_avg": 447.64, + "latency_per_key_ms": 2.247 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.cpu new file mode 100644 index 0000000..08efaa6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.991599321365356, "user_s": 144.91115, "sys_s": 119.402841, "max_rss_kb": 4416076} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.json new file mode 100644 index 0000000..679c7f8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 526.12, + "duration_min_ms": 309.14, + "duration_max_ms": 630.72, + "duration_p50_ms": 530.39, + "duration_p99_ms": 630.72, + "duration_std_ms": 55.31, + "throughput_avg_mbps": 3454.35, + "throughput_min_mbps": 2841.2, + "throughput_max_mbps": 5796.68, + "ops_per_sec_avg": 246.74, + "latency_per_key_ms": 4.11 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 13.83, + "duration_min_ms": 4.59, + "duration_max_ms": 34.44, + "duration_p50_ms": 10.05, + "duration_p99_ms": 34.44, + "duration_std_ms": 8.69, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13210.71, + "latency_per_key_ms": 0.108 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 270.64, + "duration_min_ms": 113.22, + "duration_max_ms": 352.13, + "duration_p50_ms": 278.57, + "duration_p99_ms": 352.13, + "duration_std_ms": 46.24, + "throughput_avg_mbps": 6945.21, + "throughput_min_mbps": 5089.06, + "throughput_max_mbps": 15827.65, + "ops_per_sec_avg": 496.09, + "latency_per_key_ms": 2.114 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.cpu new file mode 100644 index 0000000..19d94a1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.01717782020569, "user_s": 146.140287, "sys_s": 119.804607, "max_rss_kb": 4421840} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.json new file mode 100644 index 0000000..1607bb3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 563.31, + "duration_min_ms": 394.72, + "duration_max_ms": 688.5, + "duration_p50_ms": 574.21, + "duration_p99_ms": 688.5, + "duration_std_ms": 57.99, + "throughput_avg_mbps": 3217.56, + "throughput_min_mbps": 2602.76, + "throughput_max_mbps": 4539.89, + "ops_per_sec_avg": 229.83, + "latency_per_key_ms": 4.401 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 11.7, + "duration_min_ms": 5.57, + "duration_max_ms": 30.41, + "duration_p50_ms": 10.21, + "duration_p99_ms": 30.41, + "duration_std_ms": 6.31, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13823.12, + "latency_per_key_ms": 0.091 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 278.48, + "duration_min_ms": 156.2, + "duration_max_ms": 341.73, + "duration_p50_ms": 277.15, + "duration_p99_ms": 341.73, + "duration_std_ms": 29.78, + "throughput_avg_mbps": 6526.18, + "throughput_min_mbps": 5243.9, + "throughput_max_mbps": 11472.29, + "ops_per_sec_avg": 466.16, + "latency_per_key_ms": 2.176 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.cpu new file mode 100644 index 0000000..627aca8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.37482690811157, "user_s": 145.879043, "sys_s": 120.370603, "max_rss_kb": 4420848} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.json new file mode 100644 index 0000000..9c76448 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 534.87, + "duration_min_ms": 381.19, + "duration_max_ms": 626.32, + "duration_p50_ms": 534.97, + "duration_p99_ms": 626.32, + "duration_std_ms": 43.69, + "throughput_avg_mbps": 3374.46, + "throughput_min_mbps": 2861.18, + "throughput_max_mbps": 4701.05, + "ops_per_sec_avg": 241.03, + "latency_per_key_ms": 4.179 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 12.84, + "duration_min_ms": 4.22, + "duration_max_ms": 36.16, + "duration_p50_ms": 10.69, + "duration_p99_ms": 36.16, + "duration_std_ms": 7.72, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13641.72, + "latency_per_key_ms": 0.1 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 272.38, + "duration_min_ms": 235.07, + "duration_max_ms": 332.48, + "duration_p50_ms": 268.49, + "duration_p99_ms": 332.48, + "duration_std_ms": 23.74, + "throughput_avg_mbps": 6626.35, + "throughput_min_mbps": 5389.87, + "throughput_max_mbps": 7623.11, + "ops_per_sec_avg": 473.31, + "latency_per_key_ms": 2.128 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.cpu new file mode 100644 index 0000000..0d87d5d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.16417193412781, "user_s": 144.146429, "sys_s": 119.165919, "max_rss_kb": 4421268} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.json new file mode 100644 index 0000000..729f28e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 523.9, + "duration_min_ms": 390.69, + "duration_max_ms": 655.52, + "duration_p50_ms": 525.98, + "duration_p99_ms": 655.52, + "duration_std_ms": 43.41, + "throughput_avg_mbps": 3444.98, + "throughput_min_mbps": 2733.73, + "throughput_max_mbps": 4586.8, + "ops_per_sec_avg": 246.07, + "latency_per_key_ms": 4.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 15.98, + "duration_min_ms": 4.47, + "duration_max_ms": 42.11, + "duration_p50_ms": 13.58, + "duration_p99_ms": 42.11, + "duration_std_ms": 9.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 10954.65, + "latency_per_key_ms": 0.125 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 272.47, + "duration_min_ms": 222.5, + "duration_max_ms": 326.62, + "duration_p50_ms": 270.26, + "duration_p99_ms": 326.62, + "duration_std_ms": 26.33, + "throughput_avg_mbps": 6637.93, + "throughput_min_mbps": 5486.49, + "throughput_max_mbps": 8054.08, + "ops_per_sec_avg": 474.14, + "latency_per_key_ms": 2.129 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.cpu new file mode 100644 index 0000000..b5581af --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.20390272140503, "user_s": 130.900447, "sys_s": 106.632469, "max_rss_kb": 4412672} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.json new file mode 100644 index 0000000..bff86b5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 488.05, + "duration_min_ms": 313.89, + "duration_max_ms": 667.25, + "duration_p50_ms": 490.72, + "duration_p99_ms": 667.25, + "duration_std_ms": 82.16, + "throughput_avg_mbps": 3780.95, + "throughput_min_mbps": 2685.64, + "throughput_max_mbps": 5708.99, + "ops_per_sec_avg": 270.07, + "latency_per_key_ms": 3.813 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 12.21, + "duration_min_ms": 4.21, + "duration_max_ms": 26.18, + "duration_p50_ms": 9.64, + "duration_p99_ms": 26.18, + "duration_std_ms": 6.59, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13805.68, + "latency_per_key_ms": 0.095 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 198.82, + "duration_min_ms": 153.73, + "duration_max_ms": 329.11, + "duration_p50_ms": 176.59, + "duration_p99_ms": 329.11, + "duration_std_ms": 47.77, + "throughput_avg_mbps": 9438.24, + "throughput_min_mbps": 5444.91, + "throughput_max_mbps": 11656.86, + "ops_per_sec_avg": 674.16, + "latency_per_key_ms": 1.553 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.cpu new file mode 100644 index 0000000..265d5ae --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.54714250564575, "user_s": 131.980856, "sys_s": 105.108555, "max_rss_kb": 4412704} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.json new file mode 100644 index 0000000..75656df --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 492.03, + "duration_min_ms": 226.4, + "duration_max_ms": 665.91, + "duration_p50_ms": 504.51, + "duration_p99_ms": 665.91, + "duration_std_ms": 126.56, + "throughput_avg_mbps": 3944.71, + "throughput_min_mbps": 2691.04, + "throughput_max_mbps": 7915.16, + "ops_per_sec_avg": 281.76, + "latency_per_key_ms": 3.844 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 14.63, + "duration_min_ms": 4.89, + "duration_max_ms": 30.28, + "duration_p50_ms": 11.67, + "duration_p99_ms": 30.28, + "duration_std_ms": 8.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12060.73, + "latency_per_key_ms": 0.114 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 198.93, + "duration_min_ms": 148.33, + "duration_max_ms": 373.76, + "duration_p50_ms": 180.95, + "duration_p99_ms": 373.76, + "duration_std_ms": 50.07, + "throughput_avg_mbps": 9474.96, + "throughput_min_mbps": 4794.58, + "throughput_max_mbps": 12081.26, + "ops_per_sec_avg": 676.78, + "latency_per_key_ms": 1.554 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.cpu new file mode 100644 index 0000000..d928f21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.633742332458496, "user_s": 129.244866, "sys_s": 104.338662, "max_rss_kb": 4414452} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.json new file mode 100644 index 0000000..56e211c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 452.3, + "duration_min_ms": 256.05, + "duration_max_ms": 663.08, + "duration_p50_ms": 448.63, + "duration_p99_ms": 663.08, + "duration_std_ms": 99.31, + "throughput_avg_mbps": 4165.74, + "throughput_min_mbps": 2702.54, + "throughput_max_mbps": 6998.6, + "ops_per_sec_avg": 297.55, + "latency_per_key_ms": 3.534 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 11.08, + "duration_min_ms": 5.38, + "duration_max_ms": 28.26, + "duration_p50_ms": 9.51, + "duration_p99_ms": 28.26, + "duration_std_ms": 5.53, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 14035.95, + "latency_per_key_ms": 0.087 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 206.29, + "duration_min_ms": 150.69, + "duration_max_ms": 348.93, + "duration_p50_ms": 183.52, + "duration_p99_ms": 348.93, + "duration_std_ms": 56.2, + "throughput_avg_mbps": 9238.99, + "throughput_min_mbps": 5135.7, + "throughput_max_mbps": 11892.0, + "ops_per_sec_avg": 659.93, + "latency_per_key_ms": 1.612 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.cpu new file mode 100644 index 0000000..9911b35 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 15.796724081039429, "user_s": 49.589798, "sys_s": 103.106012, "max_rss_kb": 4367656} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.json new file mode 100644 index 0000000..278a2ec --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 109.17, + "duration_min_ms": 99.62, + "duration_max_ms": 119.81, + "duration_p50_ms": 109.91, + "duration_p99_ms": 119.81, + "duration_std_ms": 4.82, + "throughput_avg_mbps": 16446.07, + "throughput_min_mbps": 14956.62, + "throughput_max_mbps": 17988.55, + "ops_per_sec_avg": 1174.72, + "latency_per_key_ms": 0.853 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 4.55, + "duration_min_ms": 1.97, + "duration_max_ms": 12.15, + "duration_p50_ms": 4.35, + "duration_p99_ms": 12.15, + "duration_std_ms": 1.83, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 32465.23, + "latency_per_key_ms": 0.036 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 53.2, + "duration_min_ms": 51.67, + "duration_max_ms": 56.28, + "duration_p50_ms": 52.77, + "duration_p99_ms": 56.28, + "duration_std_ms": 1.12, + "throughput_avg_mbps": 33695.66, + "throughput_min_mbps": 31842.41, + "throughput_max_mbps": 34681.84, + "ops_per_sec_avg": 2406.83, + "latency_per_key_ms": 0.416 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.cpu new file mode 100644 index 0000000..27926f5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 15.841574430465698, "user_s": 49.259173, "sys_s": 103.534133, "max_rss_kb": 4366120} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.json new file mode 100644 index 0000000..2e310e6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 107.08, + "duration_min_ms": 96.04, + "duration_max_ms": 115.82, + "duration_p50_ms": 108.54, + "duration_p99_ms": 115.82, + "duration_std_ms": 5.79, + "throughput_avg_mbps": 16785.14, + "throughput_min_mbps": 15472.0, + "throughput_max_mbps": 18658.77, + "ops_per_sec_avg": 1198.94, + "latency_per_key_ms": 0.837 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 4.47, + "duration_min_ms": 1.92, + "duration_max_ms": 9.88, + "duration_p50_ms": 3.8, + "duration_p99_ms": 9.88, + "duration_std_ms": 2.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 35146.56, + "latency_per_key_ms": 0.035 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 53.22, + "duration_min_ms": 51.74, + "duration_max_ms": 56.84, + "duration_p50_ms": 52.68, + "duration_p99_ms": 56.84, + "duration_std_ms": 1.25, + "throughput_avg_mbps": 33690.43, + "throughput_min_mbps": 31525.37, + "throughput_max_mbps": 34637.76, + "ops_per_sec_avg": 2406.46, + "latency_per_key_ms": 0.416 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.cpu new file mode 100644 index 0000000..0f3dd16 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 15.67134165763855, "user_s": 48.950709, "sys_s": 103.127444, "max_rss_kb": 4366472} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.json new file mode 100644 index 0000000..bc7d2a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 106.82, + "duration_min_ms": 97.25, + "duration_max_ms": 117.05, + "duration_p50_ms": 107.63, + "duration_p99_ms": 117.05, + "duration_std_ms": 4.82, + "throughput_avg_mbps": 16809.31, + "throughput_min_mbps": 15310.25, + "throughput_max_mbps": 18427.32, + "ops_per_sec_avg": 1200.67, + "latency_per_key_ms": 0.835 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 3.65, + "duration_min_ms": 1.93, + "duration_max_ms": 10.3, + "duration_p50_ms": 2.92, + "duration_p99_ms": 10.3, + "duration_std_ms": 1.96, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 41958.23, + "latency_per_key_ms": 0.029 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 52.79, + "duration_min_ms": 51.6, + "duration_max_ms": 56.4, + "duration_p50_ms": 52.4, + "duration_p99_ms": 56.4, + "duration_std_ms": 1.07, + "throughput_avg_mbps": 33959.3, + "throughput_min_mbps": 31775.27, + "throughput_max_mbps": 34728.61, + "ops_per_sec_avg": 2425.66, + "latency_per_key_ms": 0.412 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.cpu new file mode 100644 index 0000000..a89416e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.62802004814148, "user_s": 57.095724, "sys_s": 129.641839, "max_rss_kb": 4367112} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.json new file mode 100644 index 0000000..44c3f62 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 91.57, + "duration_min_ms": 88.01, + "duration_max_ms": 98.0, + "duration_p50_ms": 91.24, + "duration_p99_ms": 98.0, + "duration_std_ms": 1.94, + "throughput_avg_mbps": 19579.05, + "throughput_min_mbps": 18285.4, + "throughput_max_mbps": 20361.56, + "ops_per_sec_avg": 1398.5, + "latency_per_key_ms": 0.715 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 4.49, + "duration_min_ms": 2.27, + "duration_max_ms": 8.81, + "duration_p50_ms": 4.17, + "duration_p99_ms": 8.81, + "duration_std_ms": 1.54, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 31344.99, + "latency_per_key_ms": 0.035 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.56, + "duration_min_ms": 44.55, + "duration_max_ms": 49.86, + "duration_p50_ms": 45.42, + "duration_p99_ms": 49.86, + "duration_std_ms": 0.86, + "throughput_avg_mbps": 39343.37, + "throughput_min_mbps": 35939.19, + "throughput_max_mbps": 40222.38, + "ops_per_sec_avg": 2810.24, + "latency_per_key_ms": 0.356 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.cpu new file mode 100644 index 0000000..ee56312 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.51633095741272, "user_s": 56.519489, "sys_s": 129.298766, "max_rss_kb": 4367952} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.json new file mode 100644 index 0000000..3a2ceff --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 92.62, + "duration_min_ms": 89.33, + "duration_max_ms": 98.53, + "duration_p50_ms": 92.5, + "duration_p99_ms": 98.53, + "duration_std_ms": 1.75, + "throughput_avg_mbps": 19354.02, + "throughput_min_mbps": 18187.16, + "throughput_max_mbps": 20060.38, + "ops_per_sec_avg": 1382.43, + "latency_per_key_ms": 0.724 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 4.38, + "duration_min_ms": 2.03, + "duration_max_ms": 7.9, + "duration_p50_ms": 4.09, + "duration_p99_ms": 7.9, + "duration_std_ms": 1.36, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 32259.68, + "latency_per_key_ms": 0.034 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.41, + "duration_min_ms": 44.49, + "duration_max_ms": 47.48, + "duration_p50_ms": 45.28, + "duration_p99_ms": 47.48, + "duration_std_ms": 0.61, + "throughput_avg_mbps": 39468.0, + "throughput_min_mbps": 37739.03, + "throughput_max_mbps": 40279.79, + "ops_per_sec_avg": 2819.14, + "latency_per_key_ms": 0.355 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.cpu new file mode 100644 index 0000000..3592612 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.671308279037476, "user_s": 55.850785, "sys_s": 131.573869, "max_rss_kb": 4368004} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.json new file mode 100644 index 0000000..4e3d2b8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 93.5, + "duration_min_ms": 90.74, + "duration_max_ms": 96.01, + "duration_p50_ms": 93.43, + "duration_p99_ms": 96.01, + "duration_std_ms": 1.34, + "throughput_avg_mbps": 19168.9, + "throughput_min_mbps": 18664.2, + "throughput_max_mbps": 19748.87, + "ops_per_sec_avg": 1369.21, + "latency_per_key_ms": 0.73 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 5.02, + "duration_min_ms": 2.17, + "duration_max_ms": 11.87, + "duration_p50_ms": 4.74, + "duration_p99_ms": 11.87, + "duration_std_ms": 1.97, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 28975.31, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.41, + "duration_min_ms": 44.21, + "duration_max_ms": 47.95, + "duration_p50_ms": 45.36, + "duration_p99_ms": 47.95, + "duration_std_ms": 0.68, + "throughput_avg_mbps": 39470.98, + "throughput_min_mbps": 37375.33, + "throughput_max_mbps": 40537.86, + "ops_per_sec_avg": 2819.36, + "latency_per_key_ms": 0.355 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.cpu new file mode 100644 index 0000000..42c1947 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.693359375, "user_s": 58.943421, "sys_s": 131.25096, "max_rss_kb": 4369664} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.json new file mode 100644 index 0000000..d2e96bc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 91.87, + "duration_min_ms": 90.21, + "duration_max_ms": 94.21, + "duration_p50_ms": 91.69, + "duration_p99_ms": 94.21, + "duration_std_ms": 0.98, + "throughput_avg_mbps": 19507.18, + "throughput_min_mbps": 19020.98, + "throughput_max_mbps": 19863.87, + "ops_per_sec_avg": 1393.37, + "latency_per_key_ms": 0.718 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 5.19, + "duration_min_ms": 1.98, + "duration_max_ms": 14.02, + "duration_p50_ms": 4.62, + "duration_p99_ms": 14.02, + "duration_std_ms": 2.34, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 29754.95, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.16, + "duration_min_ms": 43.97, + "duration_max_ms": 47.37, + "duration_p50_ms": 45.02, + "duration_p99_ms": 47.37, + "duration_std_ms": 0.74, + "throughput_avg_mbps": 39691.86, + "throughput_min_mbps": 37827.67, + "throughput_max_mbps": 40754.23, + "ops_per_sec_avg": 2835.13, + "latency_per_key_ms": 0.353 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.cpu new file mode 100644 index 0000000..cfe07b8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.75567364692688, "user_s": 58.423228, "sys_s": 132.400492, "max_rss_kb": 4368772} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.json new file mode 100644 index 0000000..01316b8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 92.83, + "duration_min_ms": 90.15, + "duration_max_ms": 99.73, + "duration_p50_ms": 92.62, + "duration_p99_ms": 99.73, + "duration_std_ms": 1.63, + "throughput_avg_mbps": 19310.34, + "throughput_min_mbps": 17967.73, + "throughput_max_mbps": 19878.2, + "ops_per_sec_avg": 1379.31, + "latency_per_key_ms": 0.725 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 5.13, + "duration_min_ms": 1.96, + "duration_max_ms": 13.08, + "duration_p50_ms": 4.7, + "duration_p99_ms": 13.08, + "duration_std_ms": 2.34, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 30531.0, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.08, + "duration_min_ms": 44.13, + "duration_max_ms": 47.0, + "duration_p50_ms": 44.89, + "duration_p99_ms": 47.0, + "duration_std_ms": 0.69, + "throughput_avg_mbps": 39756.34, + "throughput_min_mbps": 38125.69, + "throughput_max_mbps": 40610.9, + "ops_per_sec_avg": 2839.74, + "latency_per_key_ms": 0.352 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.cpu new file mode 100644 index 0000000..137b097 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.408055543899536, "user_s": 58.186957, "sys_s": 128.712939, "max_rss_kb": 4369256} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.json new file mode 100644 index 0000000..584af7c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 91.04, + "duration_min_ms": 88.55, + "duration_max_ms": 94.24, + "duration_p50_ms": 91.06, + "duration_p99_ms": 94.24, + "duration_std_ms": 1.14, + "throughput_avg_mbps": 19687.29, + "throughput_min_mbps": 19016.12, + "throughput_max_mbps": 20237.33, + "ops_per_sec_avg": 1406.23, + "latency_per_key_ms": 0.711 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 3.98, + "duration_min_ms": 2.04, + "duration_max_ms": 12.05, + "duration_p50_ms": 3.66, + "duration_p99_ms": 12.05, + "duration_std_ms": 1.87, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 37644.45, + "latency_per_key_ms": 0.031 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 45.08, + "duration_min_ms": 43.89, + "duration_max_ms": 48.46, + "duration_p50_ms": 44.99, + "duration_p99_ms": 48.46, + "duration_std_ms": 0.84, + "throughput_avg_mbps": 39763.84, + "throughput_min_mbps": 36975.42, + "throughput_max_mbps": 40829.52, + "ops_per_sec_avg": 2840.27, + "latency_per_key_ms": 0.352 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.cpu new file mode 100644 index 0000000..a56b726 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 18.587266445159912, "user_s": 40.919797, "sys_s": 72.594864, "max_rss_kb": 4365240} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.json new file mode 100644 index 0000000..209f5d7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 140.38, + "duration_min_ms": 134.41, + "duration_max_ms": 153.94, + "duration_p50_ms": 139.75, + "duration_p99_ms": 153.94, + "duration_std_ms": 3.58, + "throughput_avg_mbps": 12773.4, + "throughput_min_mbps": 11640.97, + "throughput_max_mbps": 13332.73, + "ops_per_sec_avg": 912.39, + "latency_per_key_ms": 1.097 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 3.99, + "duration_min_ms": 1.62, + "duration_max_ms": 8.85, + "duration_p50_ms": 3.77, + "duration_p99_ms": 8.85, + "duration_std_ms": 1.53, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 36895.96, + "latency_per_key_ms": 0.031 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 81.15, + "duration_min_ms": 77.07, + "duration_max_ms": 85.28, + "duration_p50_ms": 80.82, + "duration_p99_ms": 85.28, + "duration_std_ms": 1.8, + "throughput_avg_mbps": 22091.73, + "throughput_min_mbps": 21012.36, + "throughput_max_mbps": 23252.25, + "ops_per_sec_avg": 1577.98, + "latency_per_key_ms": 0.634 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.cpu new file mode 100644 index 0000000..a7418fa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 19.00681185722351, "user_s": 39.797812, "sys_s": 77.155153, "max_rss_kb": 4366216} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.json new file mode 100644 index 0000000..bd78a9f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 147.32, + "duration_min_ms": 142.72, + "duration_max_ms": 151.28, + "duration_p50_ms": 147.35, + "duration_p99_ms": 151.28, + "duration_std_ms": 1.84, + "throughput_avg_mbps": 12165.57, + "throughput_min_mbps": 11845.49, + "throughput_max_mbps": 12555.86, + "ops_per_sec_avg": 868.97, + "latency_per_key_ms": 1.151 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 2.91, + "duration_min_ms": 1.88, + "duration_max_ms": 5.14, + "duration_p50_ms": 2.78, + "duration_p99_ms": 5.14, + "duration_std_ms": 0.81, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46850.1, + "latency_per_key_ms": 0.023 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 79.85, + "duration_min_ms": 76.87, + "duration_max_ms": 85.17, + "duration_p50_ms": 79.83, + "duration_p99_ms": 85.17, + "duration_std_ms": 1.1, + "throughput_avg_mbps": 22445.29, + "throughput_min_mbps": 21041.3, + "throughput_max_mbps": 23310.7, + "ops_per_sec_avg": 1603.24, + "latency_per_key_ms": 0.624 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.cpu new file mode 100644 index 0000000..099a5a5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 19.03765892982483, "user_s": 40.253057, "sys_s": 76.759892, "max_rss_kb": 4366844} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.json new file mode 100644 index 0000000..f77b8dc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/full/ram_if16/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 50, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 147.32, + "duration_min_ms": 141.61, + "duration_max_ms": 160.39, + "duration_p50_ms": 147.38, + "duration_p99_ms": 160.39, + "duration_std_ms": 2.91, + "throughput_avg_mbps": 12168.68, + "throughput_min_mbps": 11172.88, + "throughput_max_mbps": 12654.53, + "ops_per_sec_avg": 869.19, + "latency_per_key_ms": 1.151 + }, + "op_1": { + "operation": "Lookup", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 0, + "duration_avg_ms": 4.15, + "duration_min_ms": 2.15, + "duration_max_ms": 7.62, + "duration_p50_ms": 3.85, + "duration_p99_ms": 7.62, + "duration_std_ms": 1.24, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 33725.12, + "latency_per_key_ms": 0.032 + }, + "op_2": { + "operation": "Load", + "rounds": 50, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 6400, + "total_success": 6400, + "duration_avg_ms": 80.14, + "duration_min_ms": 77.0, + "duration_max_ms": 84.76, + "duration_p50_ms": 80.04, + "duration_p99_ms": 84.76, + "duration_std_ms": 1.29, + "throughput_avg_mbps": 22365.88, + "throughput_min_mbps": 21141.39, + "throughput_max_mbps": 23274.15, + "ops_per_sec_avg": 1597.56, + "latency_per_key_ms": 0.626 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.cpu new file mode 100644 index 0000000..65d3ada --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 55.95628476142883, "user_s": 96.513609, "sys_s": 17.485904, "max_rss_kb": 4480304} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.json new file mode 100644 index 0000000..db8e5fe --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1158.52, + "duration_min_ms": 955.87, + "duration_max_ms": 1333.31, + "duration_p50_ms": 1128.32, + "duration_p99_ms": 1333.31, + "duration_std_ms": 101.51, + "throughput_avg_mbps": 1558.25, + "throughput_min_mbps": 1344.02, + "throughput_max_mbps": 1874.73, + "ops_per_sec_avg": 111.3, + "latency_per_key_ms": 9.051 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 16.99, + "duration_min_ms": 6.01, + "duration_max_ms": 30.04, + "duration_p50_ms": 17.99, + "duration_p99_ms": 30.04, + "duration_std_ms": 8.21, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 10080.96, + "latency_per_key_ms": 0.133 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 741.63, + "duration_min_ms": 687.98, + "duration_max_ms": 805.85, + "duration_p50_ms": 740.85, + "duration_p99_ms": 805.85, + "duration_std_ms": 30.43, + "throughput_avg_mbps": 2420.2, + "throughput_min_mbps": 2223.74, + "throughput_max_mbps": 2604.72, + "ops_per_sec_avg": 172.87, + "latency_per_key_ms": 5.794 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.cpu new file mode 100644 index 0000000..c48e92c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 57.01421093940735, "user_s": 97.091503, "sys_s": 20.378319, "max_rss_kb": 4549400} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.json new file mode 100644 index 0000000..d88b209 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1260.22, + "duration_min_ms": 1065.64, + "duration_max_ms": 1370.58, + "duration_p50_ms": 1252.78, + "duration_p99_ms": 1370.58, + "duration_std_ms": 79.29, + "throughput_avg_mbps": 1427.73, + "throughput_min_mbps": 1307.47, + "throughput_max_mbps": 1681.61, + "ops_per_sec_avg": 101.98, + "latency_per_key_ms": 9.845 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 15.88, + "duration_min_ms": 6.32, + "duration_max_ms": 27.62, + "duration_p50_ms": 13.59, + "duration_p99_ms": 27.62, + "duration_std_ms": 6.91, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 9845.3, + "latency_per_key_ms": 0.124 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 680.12, + "duration_min_ms": 549.32, + "duration_max_ms": 782.85, + "duration_p50_ms": 680.95, + "duration_p99_ms": 782.85, + "duration_std_ms": 57.09, + "throughput_avg_mbps": 2653.22, + "throughput_min_mbps": 2289.08, + "throughput_max_mbps": 3262.2, + "ops_per_sec_avg": 189.52, + "latency_per_key_ms": 5.313 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.cpu new file mode 100644 index 0000000..13c7ba6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.51812529563904, "user_s": 90.139151, "sys_s": 17.303096, "max_rss_kb": 4686172} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.json new file mode 100644 index 0000000..fb3de47 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1155.55, + "duration_min_ms": 1079.81, + "duration_max_ms": 1287.07, + "duration_p50_ms": 1146.53, + "duration_p99_ms": 1287.07, + "duration_std_ms": 59.84, + "throughput_avg_mbps": 1554.65, + "throughput_min_mbps": 1392.31, + "throughput_max_mbps": 1659.55, + "ops_per_sec_avg": 111.05, + "latency_per_key_ms": 9.028 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 14.46, + "duration_min_ms": 4.49, + "duration_max_ms": 31.36, + "duration_p50_ms": 12.26, + "duration_p99_ms": 31.36, + "duration_std_ms": 8.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12030.82, + "latency_per_key_ms": 0.113 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 637.49, + "duration_min_ms": 541.62, + "duration_max_ms": 689.8, + "duration_p50_ms": 654.36, + "duration_p99_ms": 689.8, + "duration_std_ms": 41.79, + "throughput_avg_mbps": 2823.56, + "throughput_min_mbps": 2597.87, + "throughput_max_mbps": 3308.62, + "ops_per_sec_avg": 201.68, + "latency_per_key_ms": 4.98 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.cpu new file mode 100644 index 0000000..4ca3aff --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.501614809036255, "user_s": 91.715473, "sys_s": 11.720357, "max_rss_kb": 4446296} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.json new file mode 100644 index 0000000..bd5a25b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 993.85, + "duration_min_ms": 771.54, + "duration_max_ms": 1091.06, + "duration_p50_ms": 1008.33, + "duration_p99_ms": 1091.06, + "duration_std_ms": 76.17, + "throughput_avg_mbps": 1814.73, + "throughput_min_mbps": 1642.44, + "throughput_max_mbps": 2322.62, + "ops_per_sec_avg": 129.62, + "latency_per_key_ms": 7.764 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 10.94, + "duration_min_ms": 4.0, + "duration_max_ms": 33.33, + "duration_p50_ms": 6.66, + "duration_p99_ms": 33.33, + "duration_std_ms": 8.52, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 18219.73, + "latency_per_key_ms": 0.085 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 662.1, + "duration_min_ms": 565.27, + "duration_max_ms": 891.02, + "duration_p50_ms": 607.45, + "duration_p99_ms": 891.02, + "duration_std_ms": 106.05, + "throughput_avg_mbps": 2764.79, + "throughput_min_mbps": 2011.18, + "throughput_max_mbps": 3170.14, + "ops_per_sec_avg": 197.48, + "latency_per_key_ms": 5.173 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.cpu new file mode 100644 index 0000000..24af21d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.305413484573364, "user_s": 29.719281, "sys_s": 7.255903, "max_rss_kb": 4365400} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.json new file mode 100644 index 0000000..a73bdd4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 980.02, + "duration_min_ms": 887.85, + "duration_max_ms": 1059.04, + "duration_p50_ms": 987.58, + "duration_p99_ms": 1059.04, + "duration_std_ms": 45.5, + "throughput_avg_mbps": 1832.36, + "throughput_min_mbps": 1692.09, + "throughput_max_mbps": 2018.37, + "ops_per_sec_avg": 130.88, + "latency_per_key_ms": 7.656 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 3.59, + "duration_min_ms": 1.98, + "duration_max_ms": 10.89, + "duration_p50_ms": 2.98, + "duration_p99_ms": 10.89, + "duration_std_ms": 1.79, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 40784.4, + "latency_per_key_ms": 0.028 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 362.31, + "duration_min_ms": 342.12, + "duration_max_ms": 380.85, + "duration_p50_ms": 361.88, + "duration_p99_ms": 380.85, + "duration_std_ms": 9.71, + "throughput_avg_mbps": 4949.45, + "throughput_min_mbps": 4705.28, + "throughput_max_mbps": 5237.94, + "ops_per_sec_avg": 353.53, + "latency_per_key_ms": 2.831 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.cpu new file mode 100644 index 0000000..edcb06b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 42.42229652404785, "user_s": 28.63155, "sys_s": 7.189844, "max_rss_kb": 4367008} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.json new file mode 100644 index 0000000..5c90865 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1052.95, + "duration_min_ms": 949.59, + "duration_max_ms": 1183.97, + "duration_p50_ms": 1053.78, + "duration_p99_ms": 1183.97, + "duration_std_ms": 58.88, + "throughput_avg_mbps": 1706.96, + "throughput_min_mbps": 1513.55, + "throughput_max_mbps": 1887.12, + "ops_per_sec_avg": 121.93, + "latency_per_key_ms": 8.226 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 4.47, + "duration_min_ms": 3.16, + "duration_max_ms": 7.4, + "duration_p50_ms": 3.93, + "duration_p99_ms": 7.4, + "duration_std_ms": 1.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 30247.65, + "latency_per_key_ms": 0.035 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 328.92, + "duration_min_ms": 311.28, + "duration_max_ms": 360.67, + "duration_p50_ms": 327.75, + "duration_p99_ms": 360.67, + "duration_std_ms": 10.51, + "throughput_avg_mbps": 5453.4, + "throughput_min_mbps": 4968.59, + "throughput_max_mbps": 5756.8, + "ops_per_sec_avg": 389.53, + "latency_per_key_ms": 2.57 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.cpu new file mode 100644 index 0000000..51013e3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 40.63573980331421, "user_s": 27.102974, "sys_s": 7.810801, "max_rss_kb": 4368120} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.json new file mode 100644 index 0000000..ad822ac --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 1038.25, + "duration_min_ms": 950.53, + "duration_max_ms": 1197.37, + "duration_p50_ms": 1024.77, + "duration_p99_ms": 1197.37, + "duration_std_ms": 55.59, + "throughput_avg_mbps": 1730.48, + "throughput_min_mbps": 1496.61, + "throughput_max_mbps": 1885.26, + "ops_per_sec_avg": 123.61, + "latency_per_key_ms": 8.111 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 6.1, + "duration_min_ms": 3.41, + "duration_max_ms": 9.75, + "duration_p50_ms": 5.53, + "duration_p99_ms": 9.75, + "duration_std_ms": 2.16, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 23638.34, + "latency_per_key_ms": 0.048 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 272.23, + "duration_min_ms": 259.71, + "duration_max_ms": 283.52, + "duration_p50_ms": 272.01, + "duration_p99_ms": 283.52, + "duration_std_ms": 5.34, + "throughput_avg_mbps": 6585.2, + "throughput_min_mbps": 6320.51, + "throughput_max_mbps": 6899.89, + "ops_per_sec_avg": 470.37, + "latency_per_key_ms": 2.127 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.cpu new file mode 100644 index 0000000..c210843 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 41.848790884017944, "user_s": 26.962668999999998, "sys_s": 8.339672, "max_rss_kb": 4364720} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.json new file mode 100644 index 0000000..2c57f17 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/d4/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 24, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 919.25, + "duration_min_ms": 726.17, + "duration_max_ms": 1125.73, + "duration_p50_ms": 876.14, + "duration_p99_ms": 1125.73, + "duration_std_ms": 130.05, + "throughput_avg_mbps": 1987.55, + "throughput_min_mbps": 1591.86, + "throughput_max_mbps": 2467.76, + "ops_per_sec_avg": 141.97, + "latency_per_key_ms": 7.182 + }, + "op_1": { + "operation": "Lookup", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 0, + "duration_avg_ms": 2.43, + "duration_min_ms": 1.57, + "duration_max_ms": 5.11, + "duration_p50_ms": 2.19, + "duration_p99_ms": 5.11, + "duration_std_ms": 0.86, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 57465.73, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 24, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3072, + "total_success": 3072, + "duration_avg_ms": 455.35, + "duration_min_ms": 433.93, + "duration_max_ms": 482.44, + "duration_p50_ms": 452.29, + "duration_p99_ms": 482.44, + "duration_std_ms": 11.94, + "throughput_avg_mbps": 3938.0, + "throughput_min_mbps": 3714.48, + "throughput_max_mbps": 4129.74, + "ops_per_sec_avg": 281.29, + "latency_per_key_ms": 3.557 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.cpu new file mode 100644 index 0000000..f667244 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 24.53126549720764, "user_s": 64.308786, "sys_s": 51.006375, "max_rss_kb": 4416852} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.json new file mode 100644 index 0000000..86ec4e4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 560.36, + "duration_min_ms": 463.05, + "duration_max_ms": 687.61, + "duration_p50_ms": 558.67, + "duration_p99_ms": 687.61, + "duration_std_ms": 56.75, + "throughput_avg_mbps": 3228.63, + "throughput_min_mbps": 2606.12, + "throughput_max_mbps": 3870.0, + "ops_per_sec_avg": 230.62, + "latency_per_key_ms": 4.378 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 11.54, + "duration_min_ms": 5.29, + "duration_max_ms": 26.9, + "duration_p50_ms": 8.18, + "duration_p99_ms": 26.9, + "duration_std_ms": 6.76, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 14203.17, + "latency_per_key_ms": 0.09 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 295.63, + "duration_min_ms": 227.73, + "duration_max_ms": 343.93, + "duration_p50_ms": 298.88, + "duration_p99_ms": 343.93, + "duration_std_ms": 26.72, + "throughput_avg_mbps": 6111.68, + "throughput_min_mbps": 5210.39, + "throughput_max_mbps": 7869.03, + "ops_per_sec_avg": 436.55, + "latency_per_key_ms": 2.31 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.cpu new file mode 100644 index 0000000..ef3b348 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.347854137420654, "user_s": 63.901266, "sys_s": 49.549011, "max_rss_kb": 4422136} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.json new file mode 100644 index 0000000..4c003ed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 533.47, + "duration_min_ms": 368.67, + "duration_max_ms": 620.44, + "duration_p50_ms": 545.86, + "duration_p99_ms": 620.44, + "duration_std_ms": 61.74, + "throughput_avg_mbps": 3409.94, + "throughput_min_mbps": 2888.29, + "throughput_max_mbps": 4860.75, + "ops_per_sec_avg": 243.57, + "latency_per_key_ms": 4.168 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 11.28, + "duration_min_ms": 5.63, + "duration_max_ms": 21.16, + "duration_p50_ms": 8.93, + "duration_p99_ms": 21.16, + "duration_std_ms": 5.21, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13567.46, + "latency_per_key_ms": 0.088 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 259.18, + "duration_min_ms": 207.86, + "duration_max_ms": 319.59, + "duration_p50_ms": 259.42, + "duration_p99_ms": 319.59, + "duration_std_ms": 22.46, + "throughput_avg_mbps": 6963.45, + "throughput_min_mbps": 5607.16, + "throughput_max_mbps": 8621.34, + "ops_per_sec_avg": 497.39, + "latency_per_key_ms": 2.025 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.cpu new file mode 100644 index 0000000..1bbce07 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.419204473495483, "user_s": 64.026219, "sys_s": 52.298894, "max_rss_kb": 4428576} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.json new file mode 100644 index 0000000..e78d1ce --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 528.23, + "duration_min_ms": 433.69, + "duration_max_ms": 635.46, + "duration_p50_ms": 508.36, + "duration_p99_ms": 635.46, + "duration_std_ms": 59.2, + "throughput_avg_mbps": 3432.12, + "throughput_min_mbps": 2819.99, + "throughput_max_mbps": 4132.0, + "ops_per_sec_avg": 245.15, + "latency_per_key_ms": 4.127 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 12.44, + "duration_min_ms": 4.25, + "duration_max_ms": 23.0, + "duration_p50_ms": 11.69, + "duration_p99_ms": 23.0, + "duration_std_ms": 5.93, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 13402.11, + "latency_per_key_ms": 0.097 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 265.41, + "duration_min_ms": 200.25, + "duration_max_ms": 317.68, + "duration_p50_ms": 264.37, + "duration_p99_ms": 317.68, + "duration_std_ms": 31.98, + "throughput_avg_mbps": 6850.43, + "throughput_min_mbps": 5640.92, + "throughput_max_mbps": 8948.61, + "ops_per_sec_avg": 489.32, + "latency_per_key_ms": 2.073 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.cpu new file mode 100644 index 0000000..462f0f9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 25.86745572090149, "user_s": 71.991116, "sys_s": 71.798695, "max_rss_kb": 15437720} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.json new file mode 100644 index 0000000..2960d57 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w64_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64}}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 5, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 1899.03, + "duration_min_ms": 1372.16, + "duration_max_ms": 2421.09, + "duration_p50_ms": 2000.58, + "duration_p99_ms": 2421.09, + "duration_std_ms": 476.73, + "throughput_avg_mbps": 3984.69, + "throughput_min_mbps": 2960.65, + "throughput_max_mbps": 5223.87, + "ops_per_sec_avg": 284.62, + "latency_per_key_ms": 3.709 + }, + "op_1": { + "operation": "Lookup", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 38.79, + "duration_min_ms": 26.21, + "duration_max_ms": 59.99, + "duration_p50_ms": 36.5, + "duration_p99_ms": 59.99, + "duration_std_ms": 13.81, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 14476.65, + "latency_per_key_ms": 0.076 + }, + "op_2": { + "operation": "Load", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 1199.02, + "duration_min_ms": 1127.3, + "duration_max_ms": 1252.98, + "duration_p50_ms": 1211.23, + "duration_p99_ms": 1252.98, + "duration_std_ms": 46.85, + "throughput_avg_mbps": 5985.67, + "throughput_min_mbps": 5720.78, + "throughput_max_mbps": 6358.55, + "ops_per_sec_avg": 427.55, + "latency_per_key_ms": 2.342 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.cpu new file mode 100644 index 0000000..3356e7e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 20.426032543182373, "user_s": 55.992759, "sys_s": 45.825422, "max_rss_kb": 4413820} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.json new file mode 100644 index 0000000..e56792e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 478.41, + "duration_min_ms": 271.41, + "duration_max_ms": 607.22, + "duration_p50_ms": 485.68, + "duration_p99_ms": 607.22, + "duration_std_ms": 91.76, + "throughput_avg_mbps": 3915.8, + "throughput_min_mbps": 2951.17, + "throughput_max_mbps": 6602.63, + "ops_per_sec_avg": 279.7, + "latency_per_key_ms": 3.738 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 14.21, + "duration_min_ms": 6.09, + "duration_max_ms": 33.04, + "duration_p50_ms": 9.36, + "duration_p99_ms": 33.04, + "duration_std_ms": 8.43, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 12012.99, + "latency_per_key_ms": 0.111 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 179.34, + "duration_min_ms": 144.27, + "duration_max_ms": 265.77, + "duration_p50_ms": 164.68, + "duration_p99_ms": 265.77, + "duration_std_ms": 34.81, + "throughput_avg_mbps": 10297.57, + "throughput_min_mbps": 6742.79, + "throughput_max_mbps": 12420.78, + "ops_per_sec_avg": 735.54, + "latency_per_key_ms": 1.401 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.cpu new file mode 100644 index 0000000..1de138e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 9.558702230453491, "user_s": 24.47155, "sys_s": 45.096017, "max_rss_kb": 4365656} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.json new file mode 100644 index 0000000..5905f34 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 100.98, + "duration_min_ms": 91.99, + "duration_max_ms": 111.13, + "duration_p50_ms": 99.37, + "duration_p99_ms": 111.13, + "duration_std_ms": 6.27, + "throughput_avg_mbps": 17809.37, + "throughput_min_mbps": 16125.27, + "throughput_max_mbps": 19481.12, + "ops_per_sec_avg": 1272.1, + "latency_per_key_ms": 0.789 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 2.87, + "duration_min_ms": 2.08, + "duration_max_ms": 5.84, + "duration_p50_ms": 2.52, + "duration_p99_ms": 5.84, + "duration_std_ms": 0.93, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47819.2, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 53.32, + "duration_min_ms": 51.57, + "duration_max_ms": 56.69, + "duration_p50_ms": 53.03, + "duration_p99_ms": 56.69, + "duration_std_ms": 1.25, + "throughput_avg_mbps": 33623.21, + "throughput_min_mbps": 31610.12, + "throughput_max_mbps": 34750.58, + "ops_per_sec_avg": 2401.66, + "latency_per_key_ms": 0.417 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.cpu new file mode 100644 index 0000000..de5da1e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 9.109633922576904, "user_s": 27.838222, "sys_s": 56.518735, "max_rss_kb": 4365672} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.json new file mode 100644 index 0000000..17e54a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 90.56, + "duration_min_ms": 88.36, + "duration_max_ms": 92.67, + "duration_p50_ms": 90.68, + "duration_p99_ms": 92.67, + "duration_std_ms": 1.03, + "throughput_avg_mbps": 19789.94, + "throughput_min_mbps": 19338.07, + "throughput_max_mbps": 20281.3, + "ops_per_sec_avg": 1413.57, + "latency_per_key_ms": 0.708 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 3.33, + "duration_min_ms": 2.15, + "duration_max_ms": 6.61, + "duration_p50_ms": 2.87, + "duration_p99_ms": 6.61, + "duration_std_ms": 1.29, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 42631.73, + "latency_per_key_ms": 0.026 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 45.83, + "duration_min_ms": 44.23, + "duration_max_ms": 48.02, + "duration_p50_ms": 45.77, + "duration_p99_ms": 48.02, + "duration_std_ms": 0.89, + "throughput_avg_mbps": 39116.47, + "throughput_min_mbps": 37318.89, + "throughput_max_mbps": 40515.55, + "ops_per_sec_avg": 2794.03, + "latency_per_key_ms": 0.358 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.cpu new file mode 100644 index 0000000..a1e9255 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 9.209383726119995, "user_s": 28.548873, "sys_s": 56.813349, "max_rss_kb": 4368980} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.json new file mode 100644 index 0000000..1787461 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 90.36, + "duration_min_ms": 88.11, + "duration_max_ms": 96.09, + "duration_p50_ms": 89.82, + "duration_p99_ms": 96.09, + "duration_std_ms": 2.18, + "throughput_avg_mbps": 19843.08, + "throughput_min_mbps": 18648.55, + "throughput_max_mbps": 20337.38, + "ops_per_sec_avg": 1417.36, + "latency_per_key_ms": 0.706 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 3.78, + "duration_min_ms": 2.16, + "duration_max_ms": 8.2, + "duration_p50_ms": 2.99, + "duration_p99_ms": 8.2, + "duration_std_ms": 1.83, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 39856.44, + "latency_per_key_ms": 0.03 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 44.91, + "duration_min_ms": 44.07, + "duration_max_ms": 47.58, + "duration_p50_ms": 44.57, + "duration_p99_ms": 47.58, + "duration_std_ms": 0.86, + "throughput_avg_mbps": 39918.84, + "throughput_min_mbps": 37663.95, + "throughput_max_mbps": 40658.19, + "ops_per_sec_avg": 2851.35, + "latency_per_key_ms": 0.351 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.cpu new file mode 100644 index 0000000..8776572 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 10.75114893913269, "user_s": 30.863249, "sys_s": 74.48632, "max_rss_kb": 15380744} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.json new file mode 100644 index 0000000..aa01acc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w64_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 5, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 339.15, + "duration_min_ms": 335.28, + "duration_max_ms": 340.36, + "duration_p50_ms": 340.03, + "duration_p99_ms": 340.36, + "duration_std_ms": 2.17, + "throughput_avg_mbps": 21135.69, + "throughput_min_mbps": 21060.35, + "throughput_max_mbps": 21378.92, + "ops_per_sec_avg": 1509.69, + "latency_per_key_ms": 0.662 + }, + "op_1": { + "operation": "Lookup", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 9.35, + "duration_min_ms": 7.08, + "duration_max_ms": 10.29, + "duration_p50_ms": 9.78, + "duration_p99_ms": 10.29, + "duration_std_ms": 1.29, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 55797.34, + "latency_per_key_ms": 0.018 + }, + "op_2": { + "operation": "Load", + "rounds": 5, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 179.76, + "duration_min_ms": 178.72, + "duration_max_ms": 180.48, + "duration_p50_ms": 179.99, + "duration_p99_ms": 180.48, + "duration_std_ms": 0.79, + "throughput_avg_mbps": 39874.98, + "throughput_min_mbps": 39716.16, + "throughput_max_mbps": 40107.22, + "ops_per_sec_avg": 2848.21, + "latency_per_key_ms": 0.351 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.cpu new file mode 100644 index 0000000..23302d6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 11.014899492263794, "user_s": 21.218587, "sys_s": 33.478995, "max_rss_kb": 4365192} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.json new file mode 100644 index 0000000..897aa94 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-xeon/scout/ram/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 137.06, + "duration_min_ms": 130.03, + "duration_max_ms": 144.73, + "duration_p50_ms": 136.76, + "duration_p99_ms": 144.73, + "duration_std_ms": 3.74, + "throughput_avg_mbps": 13083.55, + "throughput_min_mbps": 12381.9, + "throughput_max_mbps": 13781.84, + "ops_per_sec_avg": 934.54, + "latency_per_key_ms": 1.071 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 0, + "duration_avg_ms": 3.18, + "duration_min_ms": 2.04, + "duration_max_ms": 6.51, + "duration_p50_ms": 2.75, + "duration_p99_ms": 6.51, + "duration_std_ms": 1.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 43446.56, + "latency_per_key_ms": 0.025 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2560, + "total_success": 2560, + "duration_avg_ms": 80.44, + "duration_min_ms": 79.15, + "duration_max_ms": 85.77, + "duration_p50_ms": 79.86, + "duration_p99_ms": 85.77, + "duration_std_ms": 1.42, + "throughput_avg_mbps": 22284.9, + "throughput_min_mbps": 20893.84, + "throughput_max_mbps": 22640.27, + "ops_per_sec_avg": 1591.78, + "latency_per_key_ms": 0.628 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.cpu new file mode 100644 index 0000000..c9343e0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.664548873901367, "user_s": 21.522912, "sys_s": 4.311709, "max_rss_kb": 1683828} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.json new file mode 100644 index 0000000..21b91ec --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.53, + "duration_min_ms": 324.64, + "duration_max_ms": 349.44, + "duration_p50_ms": 344.05, + "duration_p99_ms": 349.44, + "duration_std_ms": 7.36, + "throughput_avg_mbps": 1312.34, + "throughput_min_mbps": 1282.03, + "throughput_max_mbps": 1380.01, + "ops_per_sec_avg": 93.74, + "latency_per_key_ms": 10.673 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.28, + "duration_min_ms": 1.07, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.24, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25208.93, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.3, + "duration_min_ms": 290.27, + "duration_max_ms": 295.67, + "duration_p50_ms": 292.15, + "duration_p99_ms": 295.67, + "duration_std_ms": 1.66, + "throughput_avg_mbps": 1532.72, + "throughput_min_mbps": 1515.22, + "throughput_max_mbps": 1543.36, + "ops_per_sec_avg": 109.48, + "latency_per_key_ms": 9.134 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.cpu new file mode 100644 index 0000000..72185ad --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.610635995864868, "user_s": 21.519627, "sys_s": 4.261531, "max_rss_kb": 1682656} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.json new file mode 100644 index 0000000..d14e0c7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.83, + "duration_min_ms": 324.73, + "duration_max_ms": 350.39, + "duration_p50_ms": 344.97, + "duration_p99_ms": 350.39, + "duration_std_ms": 8.09, + "throughput_avg_mbps": 1311.32, + "throughput_min_mbps": 1278.57, + "throughput_max_mbps": 1379.61, + "ops_per_sec_avg": 93.67, + "latency_per_key_ms": 10.682 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.4, + "duration_min_ms": 1.26, + "duration_max_ms": 1.57, + "duration_p50_ms": 1.39, + "duration_p99_ms": 1.57, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 22952.94, + "latency_per_key_ms": 0.044 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.07, + "duration_min_ms": 291.0, + "duration_max_ms": 294.21, + "duration_p50_ms": 291.83, + "duration_p99_ms": 294.21, + "duration_std_ms": 0.9, + "throughput_avg_mbps": 1533.87, + "throughput_min_mbps": 1522.74, + "throughput_max_mbps": 1539.54, + "ops_per_sec_avg": 109.56, + "latency_per_key_ms": 9.127 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.cpu new file mode 100644 index 0000000..9147838 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 34.33101534843445, "user_s": 21.486494, "sys_s": 4.369974, "max_rss_kb": 1684024} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.json new file mode 100644 index 0000000..5e2b96e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.25, + "duration_min_ms": 325.37, + "duration_max_ms": 350.41, + "duration_p50_ms": 343.68, + "duration_p99_ms": 350.41, + "duration_std_ms": 8.07, + "throughput_avg_mbps": 1313.53, + "throughput_min_mbps": 1278.52, + "throughput_max_mbps": 1376.88, + "ops_per_sec_avg": 93.82, + "latency_per_key_ms": 10.664 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.08, + "duration_max_ms": 1.51, + "duration_p50_ms": 1.3, + "duration_p99_ms": 1.51, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24609.91, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.58, + "duration_min_ms": 289.93, + "duration_max_ms": 296.63, + "duration_p50_ms": 292.14, + "duration_p99_ms": 296.63, + "duration_std_ms": 1.49, + "throughput_avg_mbps": 1531.22, + "throughput_min_mbps": 1510.3, + "throughput_max_mbps": 1545.19, + "ops_per_sec_avg": 109.37, + "latency_per_key_ms": 9.143 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.cpu new file mode 100644 index 0000000..ef8dfd0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.506529331207275, "user_s": 22.891923, "sys_s": 13.028541, "max_rss_kb": 1683904} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.json new file mode 100644 index 0000000..9f2dfe4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 426.01, + "duration_min_ms": 409.59, + "duration_max_ms": 452.85, + "duration_p50_ms": 424.82, + "duration_p99_ms": 452.85, + "duration_std_ms": 9.35, + "throughput_avg_mbps": 1052.09, + "throughput_min_mbps": 989.28, + "throughput_max_mbps": 1093.77, + "ops_per_sec_avg": 75.15, + "latency_per_key_ms": 13.313 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.28, + "duration_min_ms": 1.13, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25106.1, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 294.16, + "duration_min_ms": 291.24, + "duration_max_ms": 298.33, + "duration_p50_ms": 293.27, + "duration_p99_ms": 298.33, + "duration_std_ms": 2.06, + "throughput_avg_mbps": 1523.04, + "throughput_min_mbps": 1501.68, + "throughput_max_mbps": 1538.23, + "ops_per_sec_avg": 108.79, + "latency_per_key_ms": 9.193 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.cpu new file mode 100644 index 0000000..1936903 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.441336154937744, "user_s": 22.966714, "sys_s": 12.95962, "max_rss_kb": 1683472} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.json new file mode 100644 index 0000000..24741f4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 423.51, + "duration_min_ms": 406.02, + "duration_max_ms": 433.58, + "duration_p50_ms": 425.71, + "duration_p99_ms": 433.58, + "duration_std_ms": 7.39, + "throughput_avg_mbps": 1058.14, + "throughput_min_mbps": 1033.26, + "throughput_max_mbps": 1103.39, + "ops_per_sec_avg": 75.58, + "latency_per_key_ms": 13.235 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.3, + "duration_min_ms": 1.2, + "duration_max_ms": 1.44, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.44, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24744.52, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 293.94, + "duration_min_ms": 291.51, + "duration_max_ms": 298.47, + "duration_p50_ms": 293.55, + "duration_p99_ms": 298.47, + "duration_std_ms": 1.63, + "throughput_avg_mbps": 1524.17, + "throughput_min_mbps": 1500.99, + "throughput_max_mbps": 1536.81, + "ops_per_sec_avg": 108.87, + "latency_per_key_ms": 9.186 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.cpu new file mode 100644 index 0000000..8e681db --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.41307520866394, "user_s": 22.88951, "sys_s": 13.065618, "max_rss_kb": 1683464} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.json new file mode 100644 index 0000000..263d185 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w4_l1unaligned-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 421.51, + "duration_min_ms": 406.22, + "duration_max_ms": 429.37, + "duration_p50_ms": 422.89, + "duration_p99_ms": 429.37, + "duration_std_ms": 6.85, + "throughput_avg_mbps": 1063.12, + "throughput_min_mbps": 1043.39, + "throughput_max_mbps": 1102.86, + "ops_per_sec_avg": 75.94, + "latency_per_key_ms": 13.172 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.26, + "duration_min_ms": 1.12, + "duration_max_ms": 1.45, + "duration_p50_ms": 1.24, + "duration_p99_ms": 1.45, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25436.07, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 293.84, + "duration_min_ms": 290.28, + "duration_max_ms": 300.23, + "duration_p50_ms": 293.2, + "duration_p99_ms": 300.23, + "duration_std_ms": 2.6, + "throughput_avg_mbps": 1524.73, + "throughput_min_mbps": 1492.21, + "throughput_max_mbps": 1543.32, + "ops_per_sec_avg": 108.91, + "latency_per_key_ms": 9.183 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.cpu new file mode 100644 index 0000000..96b9acf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.67707371711731, "user_s": 21.517175, "sys_s": 4.394441, "max_rss_kb": 1701328} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.json new file mode 100644 index 0000000..f82060c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 340.98, + "duration_min_ms": 326.87, + "duration_max_ms": 348.43, + "duration_p50_ms": 343.24, + "duration_p99_ms": 348.43, + "duration_std_ms": 7.21, + "throughput_avg_mbps": 1314.44, + "throughput_min_mbps": 1285.78, + "throughput_max_mbps": 1370.57, + "ops_per_sec_avg": 93.89, + "latency_per_key_ms": 10.656 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.26, + "duration_min_ms": 1.08, + "duration_max_ms": 1.48, + "duration_p50_ms": 1.21, + "duration_p99_ms": 1.48, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25604.6, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 290.56, + "duration_min_ms": 288.77, + "duration_max_ms": 294.95, + "duration_p50_ms": 289.92, + "duration_p99_ms": 294.95, + "duration_std_ms": 1.53, + "throughput_avg_mbps": 1541.87, + "throughput_min_mbps": 1518.89, + "throughput_max_mbps": 1551.41, + "ops_per_sec_avg": 110.13, + "latency_per_key_ms": 9.08 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.cpu new file mode 100644 index 0000000..14826d9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 52.76991653442383, "user_s": 21.415328, "sys_s": 4.494217, "max_rss_kb": 1701704} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.json new file mode 100644 index 0000000..f18c73e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 341.33, + "duration_min_ms": 322.62, + "duration_max_ms": 350.04, + "duration_p50_ms": 345.3, + "duration_p99_ms": 350.04, + "duration_std_ms": 8.93, + "throughput_avg_mbps": 1313.39, + "throughput_min_mbps": 1279.86, + "throughput_max_mbps": 1388.62, + "ops_per_sec_avg": 93.81, + "latency_per_key_ms": 10.667 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.3, + "duration_min_ms": 1.15, + "duration_max_ms": 1.4, + "duration_p50_ms": 1.29, + "duration_p99_ms": 1.4, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24714.29, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 290.96, + "duration_min_ms": 289.09, + "duration_max_ms": 296.79, + "duration_p50_ms": 290.96, + "duration_p99_ms": 296.79, + "duration_std_ms": 1.74, + "throughput_avg_mbps": 1539.8, + "throughput_min_mbps": 1509.51, + "throughput_max_mbps": 1549.7, + "ops_per_sec_avg": 109.99, + "latency_per_key_ms": 9.092 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.cpu new file mode 100644 index 0000000..ee0e3dc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.566418170928955, "user_s": 21.449505, "sys_s": 4.347676, "max_rss_kb": 1700856} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.json new file mode 100644 index 0000000..1a6b8b1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 340.9, + "duration_min_ms": 324.5, + "duration_max_ms": 348.82, + "duration_p50_ms": 343.78, + "duration_p99_ms": 348.82, + "duration_std_ms": 8.15, + "throughput_avg_mbps": 1314.9, + "throughput_min_mbps": 1284.33, + "throughput_max_mbps": 1380.58, + "ops_per_sec_avg": 93.92, + "latency_per_key_ms": 10.653 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 1.31, + "duration_min_ms": 1.15, + "duration_max_ms": 1.41, + "duration_p50_ms": 1.33, + "duration_p99_ms": 1.41, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24420.53, + "latency_per_key_ms": 0.041 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.39, + "duration_min_ms": 290.37, + "duration_max_ms": 300.26, + "duration_p50_ms": 292.01, + "duration_p99_ms": 300.26, + "duration_std_ms": 2.05, + "throughput_avg_mbps": 1532.25, + "throughput_min_mbps": 1492.04, + "throughput_max_mbps": 1542.87, + "ops_per_sec_avg": 109.45, + "latency_per_key_ms": 9.137 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.cpu new file mode 100644 index 0000000..91f69fe --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.38718271255493, "user_s": 14.18813, "sys_s": 3.888314, "max_rss_kb": 1682652} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.json new file mode 100644 index 0000000..17dc7a4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 327.67, + "duration_min_ms": 311.61, + "duration_max_ms": 334.82, + "duration_p50_ms": 329.86, + "duration_p99_ms": 334.82, + "duration_std_ms": 7.7, + "throughput_avg_mbps": 1367.95, + "throughput_min_mbps": 1338.04, + "throughput_max_mbps": 1437.69, + "ops_per_sec_avg": 97.71, + "latency_per_key_ms": 10.24 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.18, + "duration_max_ms": 0.38, + "duration_p50_ms": 0.24, + "duration_p99_ms": 0.38, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 132873.53, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.72, + "duration_min_ms": 289.28, + "duration_max_ms": 294.21, + "duration_p50_ms": 291.43, + "duration_p99_ms": 294.21, + "duration_std_ms": 1.45, + "throughput_avg_mbps": 1535.78, + "throughput_min_mbps": 1522.74, + "throughput_max_mbps": 1548.65, + "ops_per_sec_avg": 109.7, + "latency_per_key_ms": 9.116 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.cpu new file mode 100644 index 0000000..01f7547 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.186447858810425, "user_s": 13.999648, "sys_s": 3.778773, "max_rss_kb": 1682448} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.json new file mode 100644 index 0000000..1e8ab7f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 328.75, + "duration_min_ms": 309.07, + "duration_max_ms": 336.03, + "duration_p50_ms": 331.77, + "duration_p99_ms": 336.03, + "duration_std_ms": 7.83, + "throughput_avg_mbps": 1363.49, + "throughput_min_mbps": 1333.21, + "throughput_max_mbps": 1449.51, + "ops_per_sec_avg": 97.39, + "latency_per_key_ms": 10.273 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.2, + "duration_max_ms": 0.31, + "duration_p50_ms": 0.24, + "duration_p99_ms": 0.31, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 130098.62, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.3, + "duration_min_ms": 289.56, + "duration_max_ms": 293.71, + "duration_p50_ms": 291.22, + "duration_p99_ms": 293.71, + "duration_std_ms": 1.11, + "throughput_avg_mbps": 1537.96, + "throughput_min_mbps": 1525.29, + "throughput_max_mbps": 1547.18, + "ops_per_sec_avg": 109.85, + "latency_per_key_ms": 9.103 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.cpu new file mode 100644 index 0000000..3d078cd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.31864333152771, "user_s": 14.218457, "sys_s": 3.724331, "max_rss_kb": 1682872} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.json new file mode 100644 index 0000000..2b2d44a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/raw_block_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":42949672960,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 328.05, + "duration_min_ms": 310.4, + "duration_max_ms": 336.91, + "duration_p50_ms": 331.79, + "duration_p99_ms": 336.91, + "duration_std_ms": 8.65, + "throughput_avg_mbps": 1366.59, + "throughput_min_mbps": 1329.74, + "throughput_max_mbps": 1443.31, + "ops_per_sec_avg": 97.61, + "latency_per_key_ms": 10.252 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.21, + "duration_max_ms": 0.33, + "duration_p50_ms": 0.23, + "duration_p99_ms": 0.33, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 131810.49, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 292.3, + "duration_min_ms": 290.0, + "duration_max_ms": 294.85, + "duration_p50_ms": 292.01, + "duration_p99_ms": 294.85, + "duration_std_ms": 1.41, + "throughput_avg_mbps": 1532.68, + "throughput_min_mbps": 1519.41, + "throughput_max_mbps": 1544.83, + "ops_per_sec_avg": 109.48, + "latency_per_key_ms": 9.135 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.cpu new file mode 100644 index 0000000..6f87d57 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.524309158325195, "user_s": 15.241745, "sys_s": 3.954937, "max_rss_kb": 1624268} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.json new file mode 100644 index 0000000..e312697 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 331.47, + "duration_min_ms": 312.8, + "duration_max_ms": 339.44, + "duration_p50_ms": 334.86, + "duration_p99_ms": 339.44, + "duration_std_ms": 8.87, + "throughput_avg_mbps": 1352.51, + "throughput_min_mbps": 1319.82, + "throughput_max_mbps": 1432.25, + "ops_per_sec_avg": 96.61, + "latency_per_key_ms": 10.358 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.55, + "duration_min_ms": 0.39, + "duration_max_ms": 0.76, + "duration_p50_ms": 0.55, + "duration_p99_ms": 0.76, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 59825.99, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.83, + "duration_min_ms": 288.12, + "duration_max_ms": 294.54, + "duration_p50_ms": 289.63, + "duration_p99_ms": 294.54, + "duration_std_ms": 1.44, + "throughput_avg_mbps": 1545.78, + "throughput_min_mbps": 1521.0, + "throughput_max_mbps": 1554.92, + "ops_per_sec_avg": 110.41, + "latency_per_key_ms": 9.057 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.cpu new file mode 100644 index 0000000..ee927db --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 45.88937187194824, "user_s": 15.281573, "sys_s": 3.871933, "max_rss_kb": 1624364} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.json new file mode 100644 index 0000000..c0c560e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 332.52, + "duration_min_ms": 316.86, + "duration_max_ms": 339.35, + "duration_p50_ms": 335.12, + "duration_p99_ms": 339.35, + "duration_std_ms": 7.66, + "throughput_avg_mbps": 1347.99, + "throughput_min_mbps": 1320.17, + "throughput_max_mbps": 1413.86, + "ops_per_sec_avg": 96.28, + "latency_per_key_ms": 10.391 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.46, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 60927.55, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.17, + "duration_min_ms": 287.74, + "duration_max_ms": 293.7, + "duration_p50_ms": 288.95, + "duration_p99_ms": 293.7, + "duration_std_ms": 1.41, + "throughput_avg_mbps": 1549.29, + "throughput_min_mbps": 1525.34, + "throughput_max_mbps": 1556.98, + "ops_per_sec_avg": 110.66, + "latency_per_key_ms": 9.037 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.cpu new file mode 100644 index 0000000..6b58797 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.52419400215149, "user_s": 15.311153000000001, "sys_s": 3.824774, "max_rss_kb": 1624640} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.json new file mode 100644 index 0000000..46aa162 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 332.33, + "duration_min_ms": 316.49, + "duration_max_ms": 339.73, + "duration_p50_ms": 335.48, + "duration_p99_ms": 339.73, + "duration_std_ms": 7.57, + "throughput_avg_mbps": 1348.74, + "throughput_min_mbps": 1318.7, + "throughput_max_mbps": 1415.52, + "ops_per_sec_avg": 96.34, + "latency_per_key_ms": 10.385 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.51, + "duration_min_ms": 0.43, + "duration_max_ms": 0.6, + "duration_p50_ms": 0.49, + "duration_p99_ms": 0.6, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 63308.85, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.54, + "duration_min_ms": 287.65, + "duration_max_ms": 297.56, + "duration_p50_ms": 289.08, + "duration_p99_ms": 297.56, + "duration_std_ms": 2.29, + "throughput_avg_mbps": 1547.4, + "throughput_min_mbps": 1505.57, + "throughput_max_mbps": 1557.44, + "ops_per_sec_avg": 110.53, + "latency_per_key_ms": 9.048 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.cpu new file mode 100644 index 0000000..03b86a5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.70018434524536, "user_s": 15.263031, "sys_s": 3.772455, "max_rss_kb": 1623048} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.json new file mode 100644 index 0000000..a8c35ee --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 331.31, + "duration_min_ms": 313.3, + "duration_max_ms": 347.83, + "duration_p50_ms": 333.39, + "duration_p99_ms": 347.83, + "duration_std_ms": 8.76, + "throughput_avg_mbps": 1353.13, + "throughput_min_mbps": 1288.0, + "throughput_max_mbps": 1429.96, + "ops_per_sec_avg": 96.65, + "latency_per_key_ms": 10.353 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.52, + "duration_min_ms": 0.41, + "duration_max_ms": 0.65, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.65, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 62560.76, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 299.09, + "duration_min_ms": 297.66, + "duration_max_ms": 302.37, + "duration_p50_ms": 298.82, + "duration_p99_ms": 302.37, + "duration_std_ms": 1.16, + "throughput_avg_mbps": 1497.89, + "throughput_min_mbps": 1481.65, + "throughput_max_mbps": 1505.05, + "ops_per_sec_avg": 106.99, + "latency_per_key_ms": 9.347 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.cpu new file mode 100644 index 0000000..ff11563 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.57813596725464, "user_s": 15.116534, "sys_s": 3.862254, "max_rss_kb": 1622252} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.json new file mode 100644 index 0000000..9859a17 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 331.99, + "duration_min_ms": 316.82, + "duration_max_ms": 357.0, + "duration_p50_ms": 333.36, + "duration_p99_ms": 357.0, + "duration_std_ms": 8.93, + "throughput_avg_mbps": 1350.34, + "throughput_min_mbps": 1254.92, + "throughput_max_mbps": 1414.05, + "ops_per_sec_avg": 96.45, + "latency_per_key_ms": 10.375 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.51, + "duration_min_ms": 0.44, + "duration_max_ms": 0.58, + "duration_p50_ms": 0.51, + "duration_p99_ms": 0.58, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 63437.27, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 298.53, + "duration_min_ms": 295.58, + "duration_max_ms": 301.99, + "duration_p50_ms": 298.25, + "duration_p99_ms": 301.99, + "duration_std_ms": 1.54, + "throughput_avg_mbps": 1500.72, + "throughput_min_mbps": 1483.48, + "throughput_max_mbps": 1515.66, + "ops_per_sec_avg": 107.19, + "latency_per_key_ms": 9.329 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.cpu new file mode 100644 index 0000000..321efab --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.663653135299683, "user_s": 15.218777, "sys_s": 3.8622259999999997, "max_rss_kb": 1622972} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.json new file mode 100644 index 0000000..867c57b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 330.84, + "duration_min_ms": 311.13, + "duration_max_ms": 337.69, + "duration_p50_ms": 334.6, + "duration_p99_ms": 337.69, + "duration_std_ms": 8.81, + "throughput_avg_mbps": 1355.06, + "throughput_min_mbps": 1326.68, + "throughput_max_mbps": 1439.91, + "ops_per_sec_avg": 96.79, + "latency_per_key_ms": 10.339 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.54, + "duration_min_ms": 0.41, + "duration_max_ms": 0.62, + "duration_p50_ms": 0.54, + "duration_p99_ms": 0.62, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 60488.97, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 299.06, + "duration_min_ms": 296.23, + "duration_max_ms": 306.03, + "duration_p50_ms": 298.7, + "duration_p99_ms": 306.03, + "duration_std_ms": 1.99, + "throughput_avg_mbps": 1498.1, + "throughput_min_mbps": 1463.93, + "throughput_max_mbps": 1512.34, + "ops_per_sec_avg": 107.01, + "latency_per_key_ms": 9.346 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.cpu new file mode 100644 index 0000000..637df86 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.42136836051941, "user_s": 15.091295, "sys_s": 3.829494, "max_rss_kb": 1624232} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.json new file mode 100644 index 0000000..dd11497 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 331.11, + "duration_min_ms": 316.98, + "duration_max_ms": 337.01, + "duration_p50_ms": 333.23, + "duration_p99_ms": 337.01, + "duration_std_ms": 6.18, + "throughput_avg_mbps": 1353.47, + "throughput_min_mbps": 1329.33, + "throughput_max_mbps": 1413.34, + "ops_per_sec_avg": 96.68, + "latency_per_key_ms": 10.347 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.46, + "duration_max_ms": 0.76, + "duration_p50_ms": 0.5, + "duration_p99_ms": 0.76, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 61472.63, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 291.59, + "duration_min_ms": 289.31, + "duration_max_ms": 293.82, + "duration_p50_ms": 291.27, + "duration_p99_ms": 293.82, + "duration_std_ms": 1.23, + "throughput_avg_mbps": 1536.43, + "throughput_min_mbps": 1524.76, + "throughput_max_mbps": 1548.51, + "ops_per_sec_avg": 109.75, + "latency_per_key_ms": 9.112 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.cpu new file mode 100644 index 0000000..42a75d8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.404944896697998, "user_s": 15.448401, "sys_s": 3.741187, "max_rss_kb": 1622840} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.json new file mode 100644 index 0000000..cc49de3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 331.11, + "duration_min_ms": 313.51, + "duration_max_ms": 338.31, + "duration_p50_ms": 333.9, + "duration_p99_ms": 338.31, + "duration_std_ms": 7.92, + "throughput_avg_mbps": 1353.77, + "throughput_min_mbps": 1324.24, + "throughput_max_mbps": 1429.0, + "ops_per_sec_avg": 96.7, + "latency_per_key_ms": 10.347 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.5, + "duration_min_ms": 0.38, + "duration_max_ms": 0.63, + "duration_p50_ms": 0.48, + "duration_p99_ms": 0.63, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 64874.49, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.33, + "duration_min_ms": 287.79, + "duration_max_ms": 292.23, + "duration_p50_ms": 288.77, + "duration_p99_ms": 292.23, + "duration_std_ms": 1.33, + "throughput_avg_mbps": 1548.43, + "throughput_min_mbps": 1533.04, + "throughput_max_mbps": 1556.69, + "ops_per_sec_avg": 110.6, + "latency_per_key_ms": 9.042 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.cpu new file mode 100644 index 0000000..31042cd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.505866050720215, "user_s": 15.147635, "sys_s": 3.9341, "max_rss_kb": 1623096} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.json new file mode 100644 index 0000000..072b04b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 333.6, + "duration_min_ms": 314.06, + "duration_max_ms": 377.56, + "duration_p50_ms": 334.49, + "duration_p99_ms": 377.56, + "duration_std_ms": 12.52, + "throughput_avg_mbps": 1344.6, + "throughput_min_mbps": 1186.55, + "throughput_max_mbps": 1426.47, + "ops_per_sec_avg": 96.04, + "latency_per_key_ms": 10.425 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.42, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.53, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 60856.42, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.64, + "duration_min_ms": 287.9, + "duration_max_ms": 302.52, + "duration_p50_ms": 288.78, + "duration_p99_ms": 302.52, + "duration_std_ms": 3.19, + "throughput_avg_mbps": 1546.9, + "throughput_min_mbps": 1480.89, + "throughput_max_mbps": 1556.08, + "ops_per_sec_avg": 110.49, + "latency_per_key_ms": 9.051 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.cpu new file mode 100644 index 0000000..5d50a5f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.548972606658936, "user_s": 18.784025, "sys_s": 4.049795, "max_rss_kb": 1688680} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.json new file mode 100644 index 0000000..9febd42 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 334.58, + "duration_min_ms": 319.04, + "duration_max_ms": 341.53, + "duration_p50_ms": 337.09, + "duration_p99_ms": 341.53, + "duration_std_ms": 7.5, + "throughput_avg_mbps": 1339.63, + "throughput_min_mbps": 1311.73, + "throughput_max_mbps": 1404.22, + "ops_per_sec_avg": 95.69, + "latency_per_key_ms": 10.456 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.52, + "duration_min_ms": 0.42, + "duration_max_ms": 0.65, + "duration_p50_ms": 0.53, + "duration_p99_ms": 0.65, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 62165.03, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 289.44, + "duration_min_ms": 288.12, + "duration_max_ms": 293.55, + "duration_p50_ms": 289.19, + "duration_p99_ms": 293.55, + "duration_std_ms": 1.31, + "throughput_avg_mbps": 1547.83, + "throughput_min_mbps": 1526.12, + "throughput_max_mbps": 1554.91, + "ops_per_sec_avg": 110.56, + "latency_per_key_ms": 9.045 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.cpu new file mode 100644 index 0000000..9837e3e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.563955068588257, "user_s": 18.778049, "sys_s": 3.939149, "max_rss_kb": 1689024} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.json new file mode 100644 index 0000000..75fb73c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 334.24, + "duration_min_ms": 317.68, + "duration_max_ms": 340.83, + "duration_p50_ms": 336.73, + "duration_p99_ms": 340.83, + "duration_std_ms": 7.46, + "throughput_avg_mbps": 1341.0, + "throughput_min_mbps": 1314.43, + "throughput_max_mbps": 1410.22, + "ops_per_sec_avg": 95.79, + "latency_per_key_ms": 10.445 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.51, + "duration_min_ms": 0.46, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.5, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 63324.33, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 290.26, + "duration_min_ms": 288.14, + "duration_max_ms": 293.13, + "duration_p50_ms": 289.75, + "duration_p99_ms": 293.13, + "duration_std_ms": 1.54, + "throughput_avg_mbps": 1543.51, + "throughput_min_mbps": 1528.35, + "throughput_max_mbps": 1554.77, + "ops_per_sec_avg": 110.25, + "latency_per_key_ms": 9.07 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.cpu new file mode 100644 index 0000000..477704a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 29.499178409576416, "user_s": 18.707184, "sys_s": 3.931915, "max_rss_kb": 1689768} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.json new file mode 100644 index 0000000..d223a38 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/drive/rust_w8_l1unaligned-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 20, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 335.18, + "duration_min_ms": 317.83, + "duration_max_ms": 341.75, + "duration_p50_ms": 337.83, + "duration_p99_ms": 341.75, + "duration_std_ms": 7.45, + "throughput_avg_mbps": 1337.25, + "throughput_min_mbps": 1310.89, + "throughput_max_mbps": 1409.57, + "ops_per_sec_avg": 95.52, + "latency_per_key_ms": 10.474 + }, + "op_1": { + "operation": "Lookup", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 0, + "duration_avg_ms": 0.54, + "duration_min_ms": 0.44, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.54, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 60177.35, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 20, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 640, + "total_success": 640, + "duration_avg_ms": 290.69, + "duration_min_ms": 288.23, + "duration_max_ms": 296.03, + "duration_p50_ms": 290.02, + "duration_p99_ms": 296.03, + "duration_std_ms": 2.16, + "throughput_avg_mbps": 1541.24, + "throughput_min_mbps": 1513.35, + "throughput_max_mbps": 1554.32, + "ops_per_sec_avg": 110.09, + "latency_per_key_ms": 9.084 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.cpu new file mode 100644 index 0000000..c2218d7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.27174997329712, "user_s": 17.92618, "sys_s": 12.088793, "max_rss_kb": 1673124} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.json new file mode 100644 index 0000000..5ba9d21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 81.83, + "duration_min_ms": 77.97, + "duration_max_ms": 85.11, + "duration_p50_ms": 82.17, + "duration_p99_ms": 85.11, + "duration_std_ms": 2.29, + "throughput_avg_mbps": 5478.79, + "throughput_min_mbps": 5263.86, + "throughput_max_mbps": 5745.73, + "ops_per_sec_avg": 391.34, + "latency_per_key_ms": 2.557 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.24, + "duration_min_ms": 0.96, + "duration_max_ms": 1.48, + "duration_p50_ms": 1.2, + "duration_p99_ms": 1.48, + "duration_std_ms": 0.16, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 26159.7, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 73.49, + "duration_min_ms": 72.05, + "duration_max_ms": 74.33, + "duration_p50_ms": 73.45, + "duration_p99_ms": 74.33, + "duration_std_ms": 0.59, + "throughput_avg_mbps": 6096.19, + "throughput_min_mbps": 6027.53, + "throughput_max_mbps": 6217.55, + "ops_per_sec_avg": 435.44, + "latency_per_key_ms": 2.297 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.cpu new file mode 100644 index 0000000..d34756a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.329779148101807, "user_s": 18.060507, "sys_s": 11.848431, "max_rss_kb": 1673692} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.json new file mode 100644 index 0000000..3fe9ad6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 85.58, + "duration_min_ms": 82.52, + "duration_max_ms": 90.44, + "duration_p50_ms": 85.22, + "duration_p99_ms": 90.44, + "duration_std_ms": 2.36, + "throughput_avg_mbps": 5238.71, + "throughput_min_mbps": 4953.71, + "throughput_max_mbps": 5428.81, + "ops_per_sec_avg": 374.19, + "latency_per_key_ms": 2.674 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.15, + "duration_max_ms": 1.39, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.39, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24971.48, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 73.36, + "duration_min_ms": 72.42, + "duration_max_ms": 74.54, + "duration_p50_ms": 73.3, + "duration_p99_ms": 74.54, + "duration_std_ms": 0.68, + "throughput_avg_mbps": 6107.52, + "throughput_min_mbps": 6010.22, + "throughput_max_mbps": 6185.8, + "ops_per_sec_avg": 436.25, + "latency_per_key_ms": 2.292 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.cpu new file mode 100644 index 0000000..e99e268 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.41520881652832, "user_s": 18.001303, "sys_s": 11.758895, "max_rss_kb": 1672256} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.json new file mode 100644 index 0000000..33d3158 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 82.06, + "duration_min_ms": 79.99, + "duration_max_ms": 85.58, + "duration_p50_ms": 81.63, + "duration_p99_ms": 85.58, + "duration_std_ms": 1.62, + "throughput_avg_mbps": 5461.34, + "throughput_min_mbps": 5234.85, + "throughput_max_mbps": 5600.73, + "ops_per_sec_avg": 390.1, + "latency_per_key_ms": 2.564 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.34, + "duration_min_ms": 1.21, + "duration_max_ms": 1.5, + "duration_p50_ms": 1.33, + "duration_p99_ms": 1.5, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 23947.66, + "latency_per_key_ms": 0.042 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 73.72, + "duration_min_ms": 72.04, + "duration_max_ms": 76.5, + "duration_p50_ms": 73.37, + "duration_p99_ms": 76.5, + "duration_std_ms": 1.13, + "throughput_avg_mbps": 6078.41, + "throughput_min_mbps": 5855.92, + "throughput_max_mbps": 6218.71, + "ops_per_sec_avg": 434.17, + "latency_per_key_ms": 2.304 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.cpu new file mode 100644 index 0000000..7031c5c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.587080478668213, "user_s": 16.588703, "sys_s": 8.498539, "max_rss_kb": 1670492} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.json new file mode 100644 index 0000000..4aa76c3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 85.37, + "duration_min_ms": 83.82, + "duration_max_ms": 86.74, + "duration_p50_ms": 85.47, + "duration_p99_ms": 86.74, + "duration_std_ms": 0.92, + "throughput_avg_mbps": 5248.12, + "throughput_min_mbps": 5165.05, + "throughput_max_mbps": 5344.96, + "ops_per_sec_avg": 374.87, + "latency_per_key_ms": 2.668 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.28, + "duration_min_ms": 1.16, + "duration_max_ms": 1.44, + "duration_p50_ms": 1.25, + "duration_p99_ms": 1.44, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25158.66, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 78.15, + "duration_min_ms": 77.21, + "duration_max_ms": 79.11, + "duration_p50_ms": 78.08, + "duration_p99_ms": 79.11, + "duration_std_ms": 0.65, + "throughput_avg_mbps": 5732.76, + "throughput_min_mbps": 5663.11, + "throughput_max_mbps": 5802.64, + "ops_per_sec_avg": 409.48, + "latency_per_key_ms": 2.442 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.cpu new file mode 100644 index 0000000..33ca6ad --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.457311630249023, "user_s": 16.502751, "sys_s": 8.44334, "max_rss_kb": 1669772} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.json new file mode 100644 index 0000000..a1a6d3c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 85.99, + "duration_min_ms": 84.35, + "duration_max_ms": 88.0, + "duration_p50_ms": 85.88, + "duration_p99_ms": 88.0, + "duration_std_ms": 1.17, + "throughput_avg_mbps": 5210.77, + "throughput_min_mbps": 5090.98, + "throughput_max_mbps": 5311.48, + "ops_per_sec_avg": 372.2, + "latency_per_key_ms": 2.687 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.25, + "duration_min_ms": 1.11, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.21, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25834.91, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 78.21, + "duration_min_ms": 77.19, + "duration_max_ms": 81.06, + "duration_p50_ms": 77.85, + "duration_p99_ms": 81.06, + "duration_std_ms": 1.07, + "throughput_avg_mbps": 5728.79, + "throughput_min_mbps": 5526.77, + "throughput_max_mbps": 5803.6, + "ops_per_sec_avg": 409.2, + "latency_per_key_ms": 2.444 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.cpu new file mode 100644 index 0000000..e66904f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.422954320907593, "user_s": 16.522213, "sys_s": 8.417591, "max_rss_kb": 1671032} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.json new file mode 100644 index 0000000..3002d52 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 83.95, + "duration_min_ms": 81.39, + "duration_max_ms": 86.74, + "duration_p50_ms": 83.7, + "duration_p99_ms": 86.74, + "duration_std_ms": 1.49, + "throughput_avg_mbps": 5337.96, + "throughput_min_mbps": 5165.07, + "throughput_max_mbps": 5504.18, + "ops_per_sec_avg": 381.28, + "latency_per_key_ms": 2.623 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.25, + "duration_min_ms": 1.07, + "duration_max_ms": 1.42, + "duration_p50_ms": 1.25, + "duration_p99_ms": 1.42, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25870.4, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 78.37, + "duration_min_ms": 77.58, + "duration_max_ms": 79.85, + "duration_p50_ms": 78.18, + "duration_p99_ms": 79.85, + "duration_std_ms": 0.78, + "throughput_avg_mbps": 5717.19, + "throughput_min_mbps": 5610.73, + "throughput_max_mbps": 5774.45, + "ops_per_sec_avg": 408.37, + "latency_per_key_ms": 2.449 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.cpu new file mode 100644 index 0000000..fb7dff2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.485129356384277, "user_s": 18.107458, "sys_s": 12.194594, "max_rss_kb": 1672496} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.json new file mode 100644 index 0000000..998c1df --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 77.82, + "duration_min_ms": 76.0, + "duration_max_ms": 79.3, + "duration_p50_ms": 77.41, + "duration_p99_ms": 79.3, + "duration_std_ms": 1.09, + "throughput_avg_mbps": 5757.95, + "throughput_min_mbps": 5649.64, + "throughput_max_mbps": 5894.83, + "ops_per_sec_avg": 411.28, + "latency_per_key_ms": 2.432 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.18, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.27, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24941.08, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 72.31, + "duration_min_ms": 71.38, + "duration_max_ms": 74.28, + "duration_p50_ms": 72.01, + "duration_p99_ms": 74.28, + "duration_std_ms": 0.91, + "throughput_avg_mbps": 6196.82, + "throughput_min_mbps": 6031.52, + "throughput_max_mbps": 6276.05, + "ops_per_sec_avg": 442.63, + "latency_per_key_ms": 2.26 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.cpu new file mode 100644 index 0000000..b78c38d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.244158506393433, "user_s": 18.01509, "sys_s": 12.279963, "max_rss_kb": 1671304} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.json new file mode 100644 index 0000000..9366809 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 77.95, + "duration_min_ms": 75.66, + "duration_max_ms": 79.58, + "duration_p50_ms": 77.89, + "duration_p99_ms": 79.58, + "duration_std_ms": 1.07, + "throughput_avg_mbps": 5748.28, + "throughput_min_mbps": 5629.7, + "throughput_max_mbps": 5921.61, + "ops_per_sec_avg": 410.59, + "latency_per_key_ms": 2.436 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.26, + "duration_min_ms": 1.13, + "duration_max_ms": 1.34, + "duration_p50_ms": 1.23, + "duration_p99_ms": 1.34, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25574.84, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.81, + "duration_min_ms": 71.12, + "duration_max_ms": 72.88, + "duration_p50_ms": 71.74, + "duration_p99_ms": 72.88, + "duration_std_ms": 0.55, + "throughput_avg_mbps": 6238.71, + "throughput_min_mbps": 6147.19, + "throughput_max_mbps": 6298.86, + "ops_per_sec_avg": 445.62, + "latency_per_key_ms": 2.244 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.cpu new file mode 100644 index 0000000..1ae110b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.275466442108154, "user_s": 18.014712, "sys_s": 12.287738, "max_rss_kb": 1672488} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.json new file mode 100644 index 0000000..9d47a0a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/python_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8}}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 77.96, + "duration_min_ms": 75.89, + "duration_max_ms": 79.41, + "duration_p50_ms": 78.2, + "duration_p99_ms": 79.41, + "duration_std_ms": 0.9, + "throughput_avg_mbps": 5747.15, + "throughput_min_mbps": 5641.42, + "throughput_max_mbps": 5903.66, + "ops_per_sec_avg": 410.51, + "latency_per_key_ms": 2.436 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.18, + "duration_max_ms": 1.42, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.42, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 24911.51, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.44, + "duration_min_ms": 70.66, + "duration_max_ms": 72.22, + "duration_p50_ms": 71.43, + "duration_p99_ms": 72.22, + "duration_std_ms": 0.45, + "throughput_avg_mbps": 6271.18, + "throughput_min_mbps": 6202.98, + "throughput_max_mbps": 6340.03, + "ops_per_sec_avg": 447.94, + "latency_per_key_ms": 2.233 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.cpu new file mode 100644 index 0000000..e97e30e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.456042766571045, "user_s": 17.488319, "sys_s": 15.221196, "max_rss_kb": 1626840} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.json new file mode 100644 index 0000000..a6ec7f4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.58, + "duration_min_ms": 70.73, + "duration_max_ms": 73.41, + "duration_p50_ms": 71.4, + "duration_p99_ms": 73.41, + "duration_std_ms": 0.74, + "throughput_avg_mbps": 6259.59, + "throughput_min_mbps": 6102.89, + "throughput_max_mbps": 6333.59, + "ops_per_sec_avg": 447.11, + "latency_per_key_ms": 2.237 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.54, + "duration_min_ms": 0.45, + "duration_max_ms": 0.63, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.63, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 60408.42, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 70.06, + "duration_min_ms": 69.68, + "duration_max_ms": 70.74, + "duration_p50_ms": 69.98, + "duration_p99_ms": 70.74, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 6395.06, + "throughput_min_mbps": 6333.18, + "throughput_max_mbps": 6428.96, + "ops_per_sec_avg": 456.79, + "latency_per_key_ms": 2.189 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.cpu new file mode 100644 index 0000000..2c7cf53 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.511960744857788, "user_s": 17.492769, "sys_s": 15.334078, "max_rss_kb": 1627036} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.json new file mode 100644 index 0000000..6c622ae --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 72.17, + "duration_min_ms": 70.97, + "duration_max_ms": 74.25, + "duration_p50_ms": 71.95, + "duration_p99_ms": 74.25, + "duration_std_ms": 0.84, + "throughput_avg_mbps": 6208.49, + "throughput_min_mbps": 6033.3, + "throughput_max_mbps": 6312.42, + "ops_per_sec_avg": 443.46, + "latency_per_key_ms": 2.255 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.54, + "duration_min_ms": 0.45, + "duration_max_ms": 0.59, + "duration_p50_ms": 0.56, + "duration_p99_ms": 0.59, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 59551.94, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 70.19, + "duration_min_ms": 69.56, + "duration_max_ms": 70.82, + "duration_p50_ms": 70.07, + "duration_p99_ms": 70.82, + "duration_std_ms": 0.34, + "throughput_avg_mbps": 6382.9, + "throughput_min_mbps": 6325.61, + "throughput_max_mbps": 6440.63, + "ops_per_sec_avg": 455.92, + "latency_per_key_ms": 2.193 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.cpu new file mode 100644 index 0000000..0b9755f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.512619018554688, "user_s": 17.405877, "sys_s": 15.356895, "max_rss_kb": 1627604} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.json new file mode 100644 index 0000000..77c3a00 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.75, + "duration_min_ms": 70.76, + "duration_max_ms": 72.53, + "duration_p50_ms": 71.66, + "duration_p99_ms": 72.53, + "duration_std_ms": 0.56, + "throughput_avg_mbps": 6244.24, + "throughput_min_mbps": 6177.0, + "throughput_max_mbps": 6330.83, + "ops_per_sec_avg": 446.02, + "latency_per_key_ms": 2.242 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.5, + "duration_min_ms": 0.41, + "duration_max_ms": 0.6, + "duration_p50_ms": 0.48, + "duration_p99_ms": 0.6, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 65032.78, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 70.15, + "duration_min_ms": 69.6, + "duration_max_ms": 72.03, + "duration_p50_ms": 69.92, + "duration_p99_ms": 72.03, + "duration_std_ms": 0.63, + "throughput_avg_mbps": 6386.42, + "throughput_min_mbps": 6219.98, + "throughput_max_mbps": 6436.41, + "ops_per_sec_avg": 456.17, + "latency_per_key_ms": 2.192 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.cpu new file mode 100644 index 0000000..382edbd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.61002492904663, "user_s": 13.985082, "sys_s": 8.176922, "max_rss_kb": 1626196} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.json new file mode 100644 index 0000000..ab85088 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 82.51, + "duration_min_ms": 81.11, + "duration_max_ms": 83.98, + "duration_p50_ms": 82.21, + "duration_p99_ms": 83.98, + "duration_std_ms": 0.92, + "throughput_avg_mbps": 5430.59, + "throughput_min_mbps": 5334.84, + "throughput_max_mbps": 5523.31, + "ops_per_sec_avg": 387.9, + "latency_per_key_ms": 2.578 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.42, + "duration_max_ms": 0.59, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.59, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 61534.56, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.19, + "duration_min_ms": 68.64, + "duration_max_ms": 69.93, + "duration_p50_ms": 69.14, + "duration_p99_ms": 69.93, + "duration_std_ms": 0.35, + "throughput_avg_mbps": 6475.16, + "throughput_min_mbps": 6406.82, + "throughput_max_mbps": 6526.85, + "ops_per_sec_avg": 462.51, + "latency_per_key_ms": 2.162 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.cpu new file mode 100644 index 0000000..d82c36a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.618296146392822, "user_s": 13.833727, "sys_s": 8.247839, "max_rss_kb": 1626132} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.json new file mode 100644 index 0000000..13d49ea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 82.91, + "duration_min_ms": 81.51, + "duration_max_ms": 84.4, + "duration_p50_ms": 82.55, + "duration_p99_ms": 84.4, + "duration_std_ms": 0.99, + "throughput_avg_mbps": 5404.08, + "throughput_min_mbps": 5307.92, + "throughput_max_mbps": 5496.53, + "ops_per_sec_avg": 386.01, + "latency_per_key_ms": 2.591 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.52, + "duration_min_ms": 0.35, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 62430.41, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.5, + "duration_min_ms": 68.03, + "duration_max_ms": 74.09, + "duration_p50_ms": 68.43, + "duration_p99_ms": 74.09, + "duration_std_ms": 1.93, + "throughput_avg_mbps": 6450.54, + "throughput_min_mbps": 6046.75, + "throughput_max_mbps": 6584.88, + "ops_per_sec_avg": 460.75, + "latency_per_key_ms": 2.172 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.cpu new file mode 100644 index 0000000..1ce7f30 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.634294271469116, "user_s": 14.09799, "sys_s": 8.061377, "max_rss_kb": 1626024} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.json new file mode 100644 index 0000000..c40fc0c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w4-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":4},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 83.0, + "duration_min_ms": 81.93, + "duration_max_ms": 84.96, + "duration_p50_ms": 82.32, + "duration_p99_ms": 84.96, + "duration_std_ms": 1.09, + "throughput_avg_mbps": 5398.17, + "throughput_min_mbps": 5273.37, + "throughput_max_mbps": 5468.35, + "ops_per_sec_avg": 385.58, + "latency_per_key_ms": 2.594 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.54, + "duration_min_ms": 0.43, + "duration_max_ms": 0.64, + "duration_p50_ms": 0.56, + "duration_p99_ms": 0.64, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 59624.14, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.54, + "duration_min_ms": 68.96, + "duration_max_ms": 70.79, + "duration_p50_ms": 69.22, + "duration_p99_ms": 70.79, + "duration_std_ms": 0.61, + "throughput_avg_mbps": 6443.09, + "throughput_min_mbps": 6328.76, + "throughput_max_mbps": 6496.66, + "ops_per_sec_avg": 460.22, + "latency_per_key_ms": 2.173 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.cpu new file mode 100644 index 0000000..4e3784e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 17.32276701927185, "user_s": 16.193585, "sys_s": 13.202846, "max_rss_kb": 1623336} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.json new file mode 100644 index 0000000..73621db --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 73.23, + "duration_min_ms": 72.08, + "duration_max_ms": 74.28, + "duration_p50_ms": 72.99, + "duration_p99_ms": 74.28, + "duration_std_ms": 0.73, + "throughput_avg_mbps": 6118.01, + "throughput_min_mbps": 6031.05, + "throughput_max_mbps": 6215.51, + "ops_per_sec_avg": 437.0, + "latency_per_key_ms": 2.289 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.68, + "duration_min_ms": 0.51, + "duration_max_ms": 1.24, + "duration_p50_ms": 0.59, + "duration_p99_ms": 1.24, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 50004.82, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.51, + "duration_min_ms": 69.2, + "duration_max_ms": 70.15, + "duration_p50_ms": 69.4, + "duration_p99_ms": 70.15, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 6445.23, + "throughput_min_mbps": 6386.69, + "throughput_max_mbps": 6474.04, + "ops_per_sec_avg": 460.37, + "latency_per_key_ms": 2.172 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.cpu new file mode 100644 index 0000000..193ec37 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.487818956375122, "user_s": 16.029345, "sys_s": 12.529165, "max_rss_kb": 1625884} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.json new file mode 100644 index 0000000..d93e2c5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.84, + "duration_min_ms": 69.81, + "duration_max_ms": 74.16, + "duration_p50_ms": 71.46, + "duration_p99_ms": 74.16, + "duration_std_ms": 1.34, + "throughput_avg_mbps": 6238.19, + "throughput_min_mbps": 6040.89, + "throughput_max_mbps": 6417.87, + "ops_per_sec_avg": 445.59, + "latency_per_key_ms": 2.245 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.56, + "duration_min_ms": 0.45, + "duration_max_ms": 0.63, + "duration_p50_ms": 0.55, + "duration_p99_ms": 0.63, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 57825.92, + "latency_per_key_ms": 0.017 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.81, + "duration_min_ms": 69.19, + "duration_max_ms": 71.43, + "duration_p50_ms": 69.41, + "duration_p99_ms": 71.43, + "duration_std_ms": 0.73, + "throughput_avg_mbps": 6417.74, + "throughput_min_mbps": 6271.79, + "throughput_max_mbps": 6474.7, + "ops_per_sec_avg": 458.41, + "latency_per_key_ms": 2.182 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.cpu new file mode 100644 index 0000000..7ec3c82 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.401586294174194, "user_s": 16.044171, "sys_s": 12.33701, "max_rss_kb": 1626408} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.json new file mode 100644 index 0000000..9e45658 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 12, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 71.47, + "duration_min_ms": 70.05, + "duration_max_ms": 73.05, + "duration_p50_ms": 71.4, + "duration_p99_ms": 73.05, + "duration_std_ms": 0.93, + "throughput_avg_mbps": 6269.66, + "throughput_min_mbps": 6133.16, + "throughput_max_mbps": 6395.2, + "ops_per_sec_avg": 447.83, + "latency_per_key_ms": 2.233 + }, + "op_1": { + "operation": "Lookup", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 0.51, + "duration_min_ms": 0.37, + "duration_max_ms": 0.61, + "duration_p50_ms": 0.49, + "duration_p99_ms": 0.61, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 63646.33, + "latency_per_key_ms": 0.016 + }, + "op_2": { + "operation": "Load", + "rounds": 12, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 69.47, + "duration_min_ms": 69.09, + "duration_max_ms": 70.32, + "duration_p50_ms": 69.35, + "duration_p99_ms": 70.32, + "duration_std_ms": 0.35, + "throughput_avg_mbps": 6448.79, + "throughput_min_mbps": 6370.82, + "throughput_max_mbps": 6484.75, + "ops_per_sec_avg": 460.63, + "latency_per_key_ms": 2.171 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.cpu new file mode 100644 index 0000000..f797b68 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.09778881072998, "user_s": 19.55292, "sys_s": 14.583869, "max_rss_kb": 4425632} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.json new file mode 100644 index 0000000..e94f2bc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 312.32, + "duration_min_ms": 312.0, + "duration_max_ms": 312.61, + "duration_p50_ms": 312.34, + "duration_p99_ms": 312.61, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 5737.79, + "throughput_min_mbps": 5732.41, + "throughput_max_mbps": 5743.57, + "ops_per_sec_avg": 409.84, + "latency_per_key_ms": 2.44 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 4.96, + "duration_min_ms": 4.86, + "duration_max_ms": 5.02, + "duration_p50_ms": 5.0, + "duration_p99_ms": 5.02, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25817.83, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 285.2, + "duration_min_ms": 284.97, + "duration_max_ms": 285.47, + "duration_p50_ms": 285.17, + "duration_p99_ms": 285.47, + "duration_std_ms": 0.26, + "throughput_avg_mbps": 6283.23, + "throughput_min_mbps": 6277.3, + "throughput_max_mbps": 6288.49, + "ops_per_sec_avg": 448.8, + "latency_per_key_ms": 2.228 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.cpu new file mode 100644 index 0000000..91f487e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.081538677215576, "user_s": 19.69166, "sys_s": 14.538308, "max_rss_kb": 4425756} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.json new file mode 100644 index 0000000..bd95f98 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 316.17, + "duration_min_ms": 313.75, + "duration_max_ms": 318.04, + "duration_p50_ms": 316.73, + "duration_p99_ms": 318.04, + "duration_std_ms": 2.2, + "throughput_avg_mbps": 5667.93, + "throughput_min_mbps": 5634.43, + "throughput_max_mbps": 5711.62, + "ops_per_sec_avg": 404.85, + "latency_per_key_ms": 2.47 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 4.87, + "duration_min_ms": 4.73, + "duration_max_ms": 5.08, + "duration_p50_ms": 4.82, + "duration_p99_ms": 5.08, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 26281.16, + "latency_per_key_ms": 0.038 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 286.2, + "duration_min_ms": 285.41, + "duration_max_ms": 287.04, + "duration_p50_ms": 286.15, + "duration_p99_ms": 287.04, + "duration_std_ms": 0.82, + "throughput_avg_mbps": 6261.41, + "throughput_min_mbps": 6243.0, + "throughput_max_mbps": 6278.79, + "ops_per_sec_avg": 447.24, + "latency_per_key_ms": 2.236 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.cpu new file mode 100644 index 0000000..f507913 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.158543348312378, "user_s": 19.6868, "sys_s": 14.524335, "max_rss_kb": 4425416} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.json new file mode 100644 index 0000000..3d2b31c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 313.39, + "duration_min_ms": 310.55, + "duration_max_ms": 316.25, + "duration_p50_ms": 313.37, + "duration_p99_ms": 316.25, + "duration_std_ms": 2.85, + "throughput_avg_mbps": 5718.42, + "throughput_min_mbps": 5666.41, + "throughput_max_mbps": 5770.41, + "ops_per_sec_avg": 408.46, + "latency_per_key_ms": 2.448 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 4.93, + "duration_min_ms": 4.72, + "duration_max_ms": 5.04, + "duration_p50_ms": 5.02, + "duration_p99_ms": 5.04, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 26004.11, + "latency_per_key_ms": 0.038 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 284.7, + "duration_min_ms": 282.64, + "duration_max_ms": 285.96, + "duration_p50_ms": 285.5, + "duration_p99_ms": 285.96, + "duration_std_ms": 1.8, + "throughput_avg_mbps": 6294.52, + "throughput_min_mbps": 6266.55, + "throughput_max_mbps": 6340.19, + "ops_per_sec_avg": 449.61, + "latency_per_key_ms": 2.224 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.cpu new file mode 100644 index 0000000..412d601 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.124885082244873, "user_s": 19.548657, "sys_s": 14.45563, "max_rss_kb": 4429068} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.json new file mode 100644 index 0000000..5e46be9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 317.19, + "duration_min_ms": 314.12, + "duration_max_ms": 321.36, + "duration_p50_ms": 316.08, + "duration_p99_ms": 321.36, + "duration_std_ms": 3.75, + "throughput_avg_mbps": 5650.16, + "throughput_min_mbps": 5576.24, + "throughput_max_mbps": 5704.87, + "ops_per_sec_avg": 403.58, + "latency_per_key_ms": 2.478 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 4.98, + "duration_min_ms": 4.77, + "duration_max_ms": 5.25, + "duration_p50_ms": 4.92, + "duration_p99_ms": 5.25, + "duration_std_ms": 0.25, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25739.69, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 289.32, + "duration_min_ms": 288.3, + "duration_max_ms": 290.83, + "duration_p50_ms": 288.83, + "duration_p99_ms": 290.83, + "duration_std_ms": 1.33, + "throughput_avg_mbps": 6193.97, + "throughput_min_mbps": 6161.72, + "throughput_max_mbps": 6215.79, + "ops_per_sec_avg": 442.43, + "latency_per_key_ms": 2.26 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.cpu new file mode 100644 index 0000000..ca968d2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.19370698928833, "user_s": 19.615019, "sys_s": 14.713828, "max_rss_kb": 4428632} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.json new file mode 100644 index 0000000..59fc4ed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 313.63, + "duration_min_ms": 308.69, + "duration_max_ms": 320.24, + "duration_p50_ms": 311.95, + "duration_p99_ms": 320.24, + "duration_std_ms": 5.95, + "throughput_avg_mbps": 5715.14, + "throughput_min_mbps": 5595.8, + "throughput_max_mbps": 5805.12, + "ops_per_sec_avg": 408.22, + "latency_per_key_ms": 2.45 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 5.02, + "duration_min_ms": 4.63, + "duration_max_ms": 5.23, + "duration_p50_ms": 5.22, + "duration_p99_ms": 5.23, + "duration_std_ms": 0.34, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25564.13, + "latency_per_key_ms": 0.039 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 288.18, + "duration_min_ms": 285.55, + "duration_max_ms": 290.42, + "duration_p50_ms": 288.57, + "duration_p99_ms": 290.42, + "duration_std_ms": 2.46, + "throughput_avg_mbps": 6218.58, + "throughput_min_mbps": 6170.27, + "throughput_max_mbps": 6275.5, + "ops_per_sec_avg": 444.18, + "latency_per_key_ms": 2.251 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.cpu new file mode 100644 index 0000000..7ea9a75 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.259813070297241, "user_s": 19.557142, "sys_s": 14.640517, "max_rss_kb": 4429060} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.json new file mode 100644 index 0000000..e777153 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/python_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"plugin\",\"module_path\":\"hypercache.integrations.lmcache_l2\",\"class_name\":\"HyperCacheL2Adapter\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32}}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 319.77, + "duration_min_ms": 317.2, + "duration_max_ms": 323.4, + "duration_p50_ms": 318.71, + "duration_p99_ms": 323.4, + "duration_std_ms": 3.23, + "throughput_avg_mbps": 5604.44, + "throughput_min_mbps": 5541.19, + "throughput_max_mbps": 5649.52, + "ops_per_sec_avg": 400.32, + "latency_per_key_ms": 2.498 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 5.12, + "duration_min_ms": 5.06, + "duration_max_ms": 5.19, + "duration_p50_ms": 5.11, + "duration_p99_ms": 5.19, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 25007.2, + "latency_per_key_ms": 0.04 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 290.15, + "duration_min_ms": 289.45, + "duration_max_ms": 290.77, + "duration_p50_ms": 290.23, + "duration_p99_ms": 290.77, + "duration_std_ms": 0.66, + "throughput_avg_mbps": 6176.17, + "throughput_min_mbps": 6162.94, + "throughput_max_mbps": 6191.09, + "ops_per_sec_avg": 441.16, + "latency_per_key_ms": 2.267 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.cpu new file mode 100644 index 0000000..b63645b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.352843523025513, "user_s": 19.5374, "sys_s": 18.918459, "max_rss_kb": 4379184} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.json new file mode 100644 index 0000000..b791997 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 280.34, + "duration_min_ms": 279.61, + "duration_max_ms": 281.31, + "duration_p50_ms": 280.11, + "duration_p99_ms": 281.31, + "duration_std_ms": 0.87, + "throughput_avg_mbps": 6392.19, + "throughput_min_mbps": 6370.29, + "throughput_max_mbps": 6408.84, + "ops_per_sec_avg": 456.58, + "latency_per_key_ms": 2.19 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.77, + "duration_min_ms": 1.64, + "duration_max_ms": 1.85, + "duration_p50_ms": 1.82, + "duration_p99_ms": 1.85, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 72605.57, + "latency_per_key_ms": 0.014 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 279.07, + "duration_min_ms": 277.69, + "duration_max_ms": 281.18, + "duration_p50_ms": 278.33, + "duration_p99_ms": 281.18, + "duration_std_ms": 1.86, + "throughput_avg_mbps": 6421.6, + "throughput_min_mbps": 6373.19, + "throughput_max_mbps": 6453.13, + "ops_per_sec_avg": 458.69, + "latency_per_key_ms": 2.18 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.cpu new file mode 100644 index 0000000..92869b2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.273911714553833, "user_s": 19.371737, "sys_s": 19.005063, "max_rss_kb": 4380176} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.json new file mode 100644 index 0000000..422a0c5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 280.37, + "duration_min_ms": 279.06, + "duration_max_ms": 281.53, + "duration_p50_ms": 280.51, + "duration_p99_ms": 281.53, + "duration_std_ms": 1.24, + "throughput_avg_mbps": 6391.68, + "throughput_min_mbps": 6365.26, + "throughput_max_mbps": 6421.48, + "ops_per_sec_avg": 456.55, + "latency_per_key_ms": 2.19 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.8, + "duration_min_ms": 1.7, + "duration_max_ms": 1.92, + "duration_p50_ms": 1.78, + "duration_p99_ms": 1.92, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 71381.38, + "latency_per_key_ms": 0.014 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 277.68, + "duration_min_ms": 276.67, + "duration_max_ms": 278.73, + "duration_p50_ms": 277.64, + "duration_p99_ms": 278.73, + "duration_std_ms": 1.03, + "throughput_avg_mbps": 6453.55, + "throughput_min_mbps": 6429.23, + "throughput_max_mbps": 6477.01, + "ops_per_sec_avg": 460.97, + "latency_per_key_ms": 2.169 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.cpu new file mode 100644 index 0000000..be65761 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.230956792831421, "user_s": 19.586596, "sys_s": 18.930261, "max_rss_kb": 4379436} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.json new file mode 100644 index 0000000..e43c937 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 280.65, + "duration_min_ms": 279.31, + "duration_max_ms": 281.4, + "duration_p50_ms": 281.23, + "duration_p99_ms": 281.4, + "duration_std_ms": 1.16, + "throughput_avg_mbps": 6385.35, + "throughput_min_mbps": 6368.12, + "throughput_max_mbps": 6415.89, + "ops_per_sec_avg": 456.1, + "latency_per_key_ms": 2.193 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.9, + "duration_min_ms": 1.76, + "duration_max_ms": 1.98, + "duration_p50_ms": 1.96, + "duration_p99_ms": 1.98, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 67445.55, + "latency_per_key_ms": 0.015 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 277.23, + "duration_min_ms": 276.72, + "duration_max_ms": 277.68, + "duration_p50_ms": 277.3, + "duration_p99_ms": 277.68, + "duration_std_ms": 0.48, + "throughput_avg_mbps": 6463.88, + "throughput_min_mbps": 6453.41, + "throughput_max_mbps": 6475.84, + "ops_per_sec_avg": 461.71, + "latency_per_key_ms": 2.166 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.cpu new file mode 100644 index 0000000..528eb31 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.363224506378174, "user_s": 19.602371, "sys_s": 19.318254, "max_rss_kb": 4381020} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.json new file mode 100644 index 0000000..69b47b4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 281.63, + "duration_min_ms": 280.21, + "duration_max_ms": 283.64, + "duration_p50_ms": 281.06, + "duration_p99_ms": 283.64, + "duration_std_ms": 1.79, + "throughput_avg_mbps": 6363.04, + "throughput_min_mbps": 6317.95, + "throughput_max_mbps": 6395.22, + "ops_per_sec_avg": 454.5, + "latency_per_key_ms": 2.2 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.82, + "duration_min_ms": 1.47, + "duration_max_ms": 2.07, + "duration_p50_ms": 1.9, + "duration_p99_ms": 2.07, + "duration_std_ms": 0.31, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 71997.3, + "latency_per_key_ms": 0.014 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 278.5, + "duration_min_ms": 277.97, + "duration_max_ms": 279.0, + "duration_p50_ms": 278.52, + "duration_p99_ms": 279.0, + "duration_std_ms": 0.51, + "throughput_avg_mbps": 6434.55, + "throughput_min_mbps": 6423.04, + "throughput_max_mbps": 6446.64, + "ops_per_sec_avg": 459.61, + "latency_per_key_ms": 2.176 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.cpu new file mode 100644 index 0000000..dc6df35 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.30762267112732, "user_s": 19.633432, "sys_s": 19.086783, "max_rss_kb": 4380992} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.json new file mode 100644 index 0000000..a90787c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 282.04, + "duration_min_ms": 281.08, + "duration_max_ms": 283.1, + "duration_p50_ms": 281.95, + "duration_p99_ms": 283.1, + "duration_std_ms": 1.01, + "throughput_avg_mbps": 6353.71, + "throughput_min_mbps": 6329.95, + "throughput_max_mbps": 6375.38, + "ops_per_sec_avg": 453.84, + "latency_per_key_ms": 2.203 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.86, + "duration_min_ms": 1.82, + "duration_max_ms": 1.9, + "duration_p50_ms": 1.85, + "duration_p99_ms": 1.9, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 68839.24, + "latency_per_key_ms": 0.015 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 278.16, + "duration_min_ms": 277.58, + "duration_max_ms": 278.91, + "duration_p50_ms": 277.99, + "duration_p99_ms": 278.91, + "duration_std_ms": 0.68, + "throughput_avg_mbps": 6442.36, + "throughput_min_mbps": 6424.92, + "throughput_max_mbps": 6455.79, + "ops_per_sec_avg": 460.17, + "latency_per_key_ms": 2.173 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.cpu new file mode 100644 index 0000000..1f5fbd3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 13.261435747146606, "user_s": 19.556199, "sys_s": 19.161914, "max_rss_kb": 4380732} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.json new file mode 100644 index 0000000..2e98b6b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector/ram_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc-l2/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 3, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 282.14, + "duration_min_ms": 280.7, + "duration_max_ms": 283.17, + "duration_p50_ms": 282.54, + "duration_p99_ms": 283.17, + "duration_std_ms": 1.28, + "throughput_avg_mbps": 6351.64, + "throughput_min_mbps": 6328.41, + "throughput_max_mbps": 6383.94, + "ops_per_sec_avg": 453.69, + "latency_per_key_ms": 2.204 + }, + "op_1": { + "operation": "Lookup", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 0, + "duration_avg_ms": 1.93, + "duration_min_ms": 1.78, + "duration_max_ms": 2.05, + "duration_p50_ms": 1.97, + "duration_p99_ms": 2.05, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 66501.64, + "latency_per_key_ms": 0.015 + }, + "op_2": { + "operation": "Load", + "rounds": 3, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 384, + "total_success": 384, + "duration_avg_ms": 278.3, + "duration_min_ms": 277.99, + "duration_max_ms": 278.56, + "duration_p50_ms": 278.36, + "duration_p99_ms": 278.56, + "duration_std_ms": 0.29, + "throughput_avg_mbps": 6439.03, + "throughput_min_mbps": 6433.12, + "throughput_max_mbps": 6446.3, + "ops_per_sec_avg": 459.93, + "latency_per_key_ms": 2.174 + } + } +} diff --git a/benchmarks/results/lmcache_rust_connector.md b/benchmarks/results/lmcache_rust_connector.md new file mode 100644 index 0000000..5534a07 --- /dev/null +++ b/benchmarks/results/lmcache_rust_connector.md @@ -0,0 +1,75 @@ +# Rust LMCache connector results + +Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5108dcc. + +Measured 2026-11-02 on one small server. These results show behaviour and relative cost on this machine. They are not throughput claims for production hardware. + +**Hardware:** Ryzen 5 5600GT (6 cores), 31 GB RAM, RTX 4060 Ti 16 GB, Intel SSDPEKNU512GZ Gen3 x2 (raw, wiped before each run). + +**Software:** Linux 6.8.0, LMCache 0.5.6 (benchmarks), LMCache 0.5.5 (vLLM run), vLLM 0.31.0, Python 3.12.3, rustc 1.99.1, HyperCache 0.9.3 plus this change. + +**Method:** `lmcache bench l2`, 14 MiB objects (one 256-token Qwen2.5-7B chunk), 8 keys per task, L1 aligned to 4 KiB unless noted, order shuffled, median of 3 runs. CPU is user plus system time for the whole bench process, including the bench's own work, and excludes the daemon. Raw data is in `lmcache_l2_raw/rust-connector/`. + +## On the drive + +4 tasks in flight, 20 rounds plus 2 warmup. All 1,920 stores and 1,920 loads succeeded in every row, with no timeouts. MB/s, with the range across runs. + +| Connector | Workers | Store | Load | Lookup p50, 32 keys | CPU user + sys | +|---|---|---|---|---|---| +| Rust | 4 | 1353 (1350-1355) | 1498 (1498-1501) | 0.52 ms | 15 + 4 s | +| Rust | 8 | 1353 (1345-1354) | 1547 (1536-1548) | 0.50 ms | 15 + 4 s | +| Rust | 16 | 1349 (1348-1353) | 1547 (1546-1549) | 0.52 ms | 15 + 4 s | +| Python | 4 | 1312 (1311-1314) | 1533 (1531-1534) | 1.30 ms | 22 + 4 s | +| Python | 8 | 1314 (1313-1315) | 1540 (1532-1542) | 1.29 ms | 21 + 4 s | +| LMCache `raw_block` | 8 | 1367 (1363-1368) | 1536 (1533-1538) | 0.24 ms | 14 + 4 s | +| Rust, unaligned L1 | 8 | 1340 (1337-1341) | 1544 (1541-1548) | 0.53 ms | 19 + 4 s | +| Python, unaligned L1 | 4 | 1058 (1052-1063) | 1524 (1523-1525) | 1.28 ms | 23 + 13 s | + +- **The drive sets the limit here.** At 8 workers, Rust stores are 3.0% faster than Python's and loads 0.5% faster. Compared with `raw_block`, Rust stores are 1.0% slower and loads 0.7% faster, while Rust also checks a CRC32 on every chunk. +- **Lookups are 2.6 times faster than Python's,** but still about twice `raw_block`'s, which doesn't ask a daemon. +- **CPU:** Rust adds about 1 s of user time over `raw_block` for this workload, and Python adds about 8 s. +- **Unaligned L1 buffers:** Rust stores are 27% faster than Python's, though Python ran 4 workers here and Rust 8. Prefer 4 KiB alignment either way, because it saves 4 s of user time on the Rust side. +- **Rust at 4 workers loads 2.3% slower than Python at 4 workers.** A Rust worker reads one object's chunks in turn, while Python reads them in parallel. Use 8 or more workers. + +## On the RAM tier, with no drive limit + +18 runs at 4 in flight (12 rounds plus 2 warmup) and 12 runs at 16 in flight (3 rounds plus 1 warmup). All 1,152 stores and 1,152 loads per row succeeded. + +| Connector | Workers | In flight | Store | Load | Lookup p50 | CPU user + sys | +|---|---|---|---|---|---|---| +| Rust | 4 | 4 | 5404 | 6451 | 0.52 ms | 14 + 8 s | +| Rust | 8 | 4 | 6238 | 6445 | 0.55 ms | 16 + 13 s | +| Rust | 16 | 4 | 6244 | 6386 | 0.52 ms | 17 + 15 s | +| Rust | 16 | 16 | 6392 | 6454 | 1.82 ms | 20 + 19 s | +| Rust | 32 | 16 | 6354 | 6439 | 1.90 ms | 20 + 19 s | +| Python | 4 | 4 | 5248 | 5729 | 1.25 ms | 17 + 8 s | +| Python | 8 | 4 | 5748 | 6239 | 1.26 ms | 18 + 12 s | +| Python | 16 | 4 | 5461 | 6096 | 1.26 ms | 18 + 12 s | +| Python | 16 | 16 | 5718 | 6283 | 5.00 ms | 20 + 15 s | +| Python | 32 | 16 | 5650 | 6194 | 5.11 ms | 20 + 15 s | + +Best against best, Rust stores are about 11% faster than Python's and loads about 3% faster. At 16 in flight, Rust's 32-key lookups take 1.8 ms against Python's 5 ms. + +Neither connector scales past about 6.4 GB/s here, so this comparison also hits a limit outside the connector: + +- **It isn't LMCache.** `benchmarks/lmcache_connector_direct.py`, which calls the connector with LMCache out of the path, gives the same result: store 5.5-6.5 GB/s and load 6.4-6.7 GB/s at 4 to 32 workers. +- **It isn't the checksum.** One thread computes CRC32 at about 28 GB/s, on cached data. +- **Memory is the likely cause.** With no connector or daemon involved, reading tmpfs reaches 12 GB/s on 1 thread and only 9-10 GB/s on 4 to 12 threads, and memcpy falls from 36 GB/s on 1 thread to 16 GB/s on 12. Those tests repeat over 4 MiB buffers, so they're a best case for this machine. + +This means these results can't show how the connector behaves above about 6.5 GB/s. That needs a machine with more memory bandwidth. + +## With vLLM + +Qwen2.5-7B-Instruct-AWQ, a prompt that fills 37 chunks, one run, on LMCache 0.5.5 with the raw drive. + +| | Rust connector | Python adapter (earlier run) | +|---|---|---| +| Cold (compute) | 3.549 s | 3.558 s | +| Hit in L1 | 0.199 s | 0.201 s | +| Hit on NVMe, after flushing L1 | 0.594 s | 0.619 s | +| Reading 37 chunks from the drive | 377 ms | 402 ms | +| Output identical across all three | yes | yes | + +## Safety checks + +`scripts/e2e/lmcache_l2_e2e.py --connector rust` passed 34 of 34 on LMCache 0.5.5 and on 0.5.6. That covers the 18 checks the Python adapter passes, plus: no-copy O_DIRECT, partial last blocks, reading the same data through the page cache, loading each other's blocks in both directions, a block deleted while locked, and concurrent tasks returning the right bytes. The Python adapter still passes 18 of 18 on both versions. `cargo test` in `lmcache-connector/` has 31 tests and runs without Python. diff --git a/benchmarks/results/lmcache_rust_connector_xeon.md b/benchmarks/results/lmcache_rust_connector_xeon.md new file mode 100644 index 0000000..811726f --- /dev/null +++ b/benchmarks/results/lmcache_rust_connector_xeon.md @@ -0,0 +1,117 @@ +# Rust LMCache connector results: Xeon VM, 4 network disks + +Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5108dcc. + +Measured 2026-11-03 on a rented cloud VM. Raw data is in `lmcache_l2_raw/rust-connector-xeon/`. Earlier results from a small server are in `lmcache_rust_connector.md`. + +**Hardware:** Xeon 6776P (KVM guest, 24 vCPUs), 214 GB RAM, RTX PRO 6000 Blackwell (97,887 MiB), 4 virtio network disks of 2.3-2.4 TiB, sold as capped at 2 GB/s each. + +**Software:** Linux 6.11.0, LMCache 0.5.6, vLLM 0.33.0, Python 3.12.3, rustc 1.99.1, HyperCache 0.9.3 plus this change. + +**Method:** `lmcache bench l2`, 14 MiB objects (one 256-token Qwen2.5-7B chunk), 8 keys per task, L1 aligned to 4 KiB, order shuffled, median of 3 runs with the range in brackets. Every run was checked for the expected key count; all succeeded with no timeouts. CPU is user plus system time for the whole bench process, including the bench's own work, and excludes the daemon. The disks can't discard, so runs overwrite earlier data instead of starting wiped. + +## What the VM can do without HyperCache + +fio, 4 MiB blocks, queue depth 16 per drive, 3 runs of 20 s. The drives can't be tested in isolation from the VM's limits, and the disks' provider wasn't asked about them. + +| Drives | Read MB/s | Write MB/s | +|---|---|---| +| 1 | 2157-2182 | 993-1478 | +| 2 | 4303-4338 | 1933-2418 | +| 3 | 5495-6019 | 2080-2219 | +| 4 | 5688-5899 | 1988-2240 | + +- **Four disks don't reach 8 GB/s.** Reads stop near 6 GB/s from 3 drives on, and writes stop near 2.2 GB/s from 2 drives on. Latency rises as they flatten and fio's CPU use stays low, which points to a shared limit on the VM, though that isn't confirmed. +- **Memory is not a limit here.** tmpfs reads reach 97-99 GB/s on 12 and 24 threads, against 9-10 GB/s on the earlier server. memcpy reaches 130 GB/s. + +## RAM tier, no drive limit + +16 tasks in flight, 50 rounds plus 2 warmup, about 94 GB per phase. + +| Connector | Workers | Store MB/s | Load MB/s | Lookup p50 | CPU user + sys | +|---|---|---|---|---|---| +| Rust | 8 | 12169 [12166-12773] | 22366 [22092-22445] | 3.77 ms | 40 + 77 s | +| Rust | 16 | 16785 [16446-16809] | 33696 [33690-33959] | 3.80 ms | 49 + 103 s | +| Rust | 32 | 19354 [19169-19579] | 39468 [39343-39471] | 4.17 ms | 57 + 130 s | +| Rust | 64 | 19507 [19310-19687] | 39756 [39692-39764] | 4.62 ms | 58 + 131 s | +| Python | 8 | 3945 [3781-4166] | 9438 [9239-9475] | 9.64 ms | 131 + 105 s | +| Python | 16 | 3444 [3306-3454] | 6267 [6158-6945] | 10.05 ms | 145 + 121 s | +| Python | 32 | 3374 [3218-3445] | 6626 [6526-6638] | 10.69 ms | 146 + 120 s | + +- Best against best, Rust stores 4.9 times as fast and loads 4.2 times as fast. +- **Python gets slower with more workers,** which fits contention on the interpreter lock, though that wasn't profiled. Rust gets faster up to 32 workers, then flattens. +- What stops Rust near 19.5 and 39.8 GB/s wasn't identified. A load phase at this speed lasts only about 2.4 s. + +## On the drives + +16 tasks in flight unless noted. + +| Drives | Connector | Workers | Store MB/s | Load MB/s | Lookup p50 | CPU user + sys | +|---|---|---|---|---|---|---| +| 4 | Rust | 16 | 1811 [1804-1951] | 6018 [5529-6175] | 3.98 ms | 40 + 10 s | +| 4 | Rust | 32 | 1748 [1700-1768] | 6418 [5869-7177] | 4.41 ms | 41 + 11 s | +| 4 | Rust | 64 | 1663 [1619-1704] | 5839 [5643-6978] | 3.22 ms | 43 + 10 s | +| 4 | Rust | 128 | 1675 [1606-1681] | 5728 [5583-6485] | 3.89 ms | 42 + 11 s | +| 4 | Python | 8 | 1777 [1707-1850] | 2526 [2310-2646] | 8.66 ms | 133 + 15 s | +| 4 | Python | 64 | 1496 [1452-1593] | 2758 [2567-3288] | 11.48 ms | 151 + 27 s | +| 2 | Rust | 16 | 1698 [1638-1827] | 4037 [3989-4054] | 4.35 ms | 27 + 8 s | +| 2 | Rust | 32 | 1826 [1744-1964] | 4049 [4017-4081] | 3.09 ms | 29 + 9 s | +| 2 | Rust | 64 | 1842 [1779-1865] | 4047 [4034-4050] | 3.92 ms | 29 + 9 s | +| 2 | Python | 16 | 1545 [1487-1589] | 2952 [2692-3108] | 9.02 ms | 89 + 15 s | +| 2 | Python | 32 | 1492 [1380-1526] | 2774 [2456-3032] | 9.03 ms | 94 + 19 s | +| 1 | Rust | 8 | 1061 [1027-1393] | 2145 [2082-2165] | 2.98 ms | 19 + 7 s | +| 1 | Rust | 16 | 1022 [988-1111] | 2085 [2067-2092] | 3.07 ms | 19 + 8 s | +| 1 | Rust | 32 | 953 [950-996] | 2087 [2079-2089] | 3.99 ms | 18 + 7 s | +| 1 | Python | 8 | 1008 [955-1043] | 2234 [2164-2257] | 7.09 ms | 48 + 8 s | +| 1 | Python | 16 | 1113 [1047-1214] | 2157 [2123-2165] | 6.04 ms | 50 + 8 s | +| 1 | `raw_block` | 8 | 1132 [1070-1169] | 2101 [2091-2107] | 0.60 ms | 14 + 5 s | +| 1 | `raw_block` | 16 | 1039 [1019-1073] | 2110 [2090-2112] | 0.66 ms | 14 + 5 s | +| 1 | `raw_block` | 32 | 1011 [1000-1040] | 2082 [2082-2110] | 0.66 ms | 13 + 5 s | +| 1, 4 in flight | Rust | 8 | 1078 [1063-1146] | 2377 [2372-2378] | 2.01 ms | 18 + 4 s | +| 1, 4 in flight | Python | 8 | 1106 [958-1138] | 2292 [2290-2308] | 3.98 ms | 46 + 5 s | +| 1, 4 in flight | `raw_block` | 8 | 1050 [1011-1135] | 2425 [2425-2442] | 0.21 ms | 14 + 3 s | + +- **On 4 drives, Rust loads about 2.3 times as fast as Python and reaches the VM's read limit.** Python stays near 2.5-3 GB/s on both 2 and 4 drives, so it stops scaling past 2 drives. +- **Rust uses about a third of Python's CPU** on 4 drives for the same data. +- **On one drive, all three connectors tie on throughput,** because the drive sets the limit. `raw_block` handles one device only, so it has no 2- or 4-drive rows. +- **Stores are held back by the VM's write limit,** so they say little about the connectors. Rust leads on 2 drives by about 19%, and the 4-drive results overlap. +- **Lookups:** Rust is 2 to 3 times as fast as Python, but `raw_block`, which doesn't ask a daemon, is 5 to 10 times as fast as Rust. + +## With vLLM + +Qwen2.5-7B-Instruct-AWQ, revision b250375, 4 drives, a prompt that fills 37 chunks, LMCache L1 of 3 GB. Rust ran 32 workers and Python 8. Time to first token, 3 runs. + +| | Rust connector | Python adapter | +|---|---|---| +| Cold (compute) | 0.565-0.572 s | 0.563-0.571 s | +| Repeat straight after, L1 | 0.119-0.127 s | 0.297-0.317 s | +| After flushing L1, from the drives | 0.182-0.207 s | 0.301-0.331 s | +| Reading 37 chunks from the drives, all 6 runs | 89-113 ms | 195-249 ms | + +Why the repeat in L1 differs by connector wasn't investigated. This GPU computes the prompt quickly, so the cache saves far less time than on the earlier server, where a cold run took 3.5 s. + +## Open issue: output sometimes differs after a cache hit + +The same prompt at temperature 0 didn't always return the same text. Runs where any answer differed: + +| Setup | Runs that differed | +|---|---| +| No cache, 6 requests | 0 of 2 | +| vLLM's own prefix cache only, 6 requests | 0 of 2 | +| LMCache L1 only, no HyperCache, 6 requests | 1 of 2 | +| LMCache with Rust connector, first test | 2 of 3 | +| LMCache with Python adapter, first test | 2 of 3 | +| LMCache with Rust connector, second test, 5 requests | 1 of 3 | +| LMCache with Python adapter, second test, 5 requests | 0 of 3 | + +- **It happens with no HyperCache in the path,** and it isn't specific to either connector. No checksum errors appeared in the second test's logs. +- In the two runs of the second test and the L1-only test that differed, the first request gave the usual answer and every cached request gave the same other answer. Both answers read normally: "...and storage location on one of 3..." against "...and stored on one of 37...". +- **Cause not found.** Rounding differences between a full computation and a cached one could explain it, but that isn't shown, and nor is a bug in LMCache or vLLM ruled out. The earlier server, on vLLM 0.31.0 and LMCache 0.5.5, gave identical output in the runs recorded, which were few. + +## Safety checks + +`scripts/e2e/lmcache_l2_e2e.py` on 4 drives, on LMCache 0.5.6: Rust 34 of 34, Python 18 of 18. Both were run twice because the second run, meant for 0.5.5, also loaded 0.5.6 from this image. `cargo test` in `lmcache-connector/` passed 31 of 31. The 0.5.5 pass comes from the earlier server. + +## Runs thrown away + +The first full run of 87 was invalid: a script bug overwrote the in-flight setting, so most runs used 1 task in flight. It is not included. A shorter first pass, with one run per setup, is kept in `scout/`. diff --git a/client-py/hypercache/integrations/lmcache_l2.py b/client-py/hypercache/integrations/lmcache_l2.py deleted file mode 100644 index 0138aa2..0000000 --- a/client-py/hypercache/integrations/lmcache_l2.py +++ /dev/null @@ -1,427 +0,0 @@ -""" -LMCache L2 adapter backed by the HyperCache daemon. - -Lets an LMCache MP-mode server keep KV-cache chunks on HyperCache's RAM and NVMe tiers. -LMCache loads it as a plugin, so `hypercache` must be importable by the LMCache server: - - { - "type": "plugin", - "module_path": "hypercache.integrations.lmcache_l2", - "class_name": "HyperCacheL2Adapter", - "adapter_params": { - "namespace": "qwen2.5-7b-awq-rev1234", - "socket_path": "/run/hypercache/hypercache.sock", - "tier": "nvme" - } - } - -Behaviour worth knowing: - -- Blocks are LOCAL_ONLY. They are never flushed to a backend and stay evictable, because - KV data derives from user prompts and can be recomputed. -- `namespace` is required. LMCache's key has a model name but no revision, dtype or engine - settings, so changing weights under the same name would otherwise return wrong KV data. - Set it to something that changes when any of those change. -- Any doubt about a block is a miss. Lookup only accepts committed blocks with a checksum - for every chunk, and load verifies every chunk before reporting success. -- Capacity belongs to the daemon, which evicts under pressure. LMCache's global eviction is - off, so `list_l2_keys` and IsolatedLRU quotas are not supported. The daemon can evict a - block after lookup succeeded; that load then reports a miss for the key. - -Requires LMCache 0.5.5 or 0.5.6, and a daemon with local-only commit support. Against an -older daemon, stores fail before any data is written and lookups miss. - -Only this module imports LMCache. `hypercache.integrations` must not import it. -""" - -from __future__ import annotations - -import itertools -import logging -import threading -import zlib -from concurrent.futures import ThreadPoolExecutor -from typing import Any, Callable, Dict, List, Optional -from urllib.parse import quote - -import torch # noqa: F401 # must precede lmcache_native -from lmcache.lmcache_native import Bitmap -from lmcache.v1.distributed.internal_api import L2StoreResult -from lmcache.v1.distributed.l2_adapters.base import L2AdapterInterface, L2TaskId -from lmcache.v1.distributed.l2_adapters.config import L2AdapterConfigBase -from lmcache.v1.platform import create_event_notifier - -from hypercache.client import HyperCacheClient, LocateResult -from hypercache.datapath import ChecksumMismatchError, DirectBlockReader, DirectBlockWriter - -logger = logging.getLogger(__name__) - -_LOCAL_ONLY = "LOCAL_ONLY" - - -class HyperCacheL2AdapterConfig(L2AdapterConfigBase): - """Config for HyperCacheL2Adapter.""" - - def __init__( - self, - namespace: str, - socket_path: Optional[str] = None, - tier: str = "nvme", - num_workers: int = 4, - timeout_s: float = 30.0, - ): - if not namespace: - raise ValueError("namespace is required: use a value that changes when the model weights or dtype change") - if num_workers < 1: - raise ValueError("num_workers must be at least 1") - self.namespace = namespace - self.socket_path = socket_path - self.tier = tier - self.num_workers = num_workers - self.timeout_s = timeout_s - - @classmethod - def from_dict(cls, d: dict) -> "HyperCacheL2AdapterConfig": - return cls( - namespace=d.get("namespace", ""), - socket_path=d.get("socket_path"), - tier=d.get("tier", "nvme"), - num_workers=int(d.get("num_workers", 4)), - timeout_s=float(d.get("timeout_s", 30.0)), - ) - - @classmethod - def help(cls) -> str: - return ( - "HyperCacheL2Adapter config fields:\n" - "- namespace (str, required): model fingerprint; change it when weights or dtype change\n" - "- socket_path (str): daemon socket (default: the client's default path)\n" - "- tier (str): 'nvme' or 'ram' (default 'nvme')\n" - "- num_workers (int): parallel chunk reads and writes per direction (default 4)\n" - "- timeout_s (float): daemon request timeout in seconds (default 30)\n" - ) - - -class HyperCacheL2Adapter(L2AdapterInterface): - """Stores LMCache objects in HyperCache. Called from two LMCache controller threads.""" - - def __init__(self, config: Any, **_kwargs: object): - if isinstance(config, dict): - config = HyperCacheL2AdapterConfig.from_dict(config) - super().__init__(0) # 0 turns off LMCache's global eviction: the daemon owns capacity - self._config = config - self._namespace = quote(config.namespace, safe="") - - self._store_efd = create_event_notifier() - self._lookup_efd = create_event_notifier() - self._load_efd = create_event_notifier() - - self._lock = threading.Lock() - self._task_ids = itertools.count() - self._done_store: Dict[L2TaskId, L2StoreResult] = {} - self._done_lookup: Dict[L2TaskId, Bitmap] = {} - self._done_load: Dict[L2TaskId, Bitmap] = {} - self._locks: Dict[str, int] = {} - self._storing: set = set() - self._daemon_supports_local_only = False - self._closed = False - self._counters = {"checksum_failures": 0, "load_failures": 0, "store_failures": 0} - - self._clients = threading.local() - self._all_clients: List[HyperCacheClient] = [] - self._reader = DirectBlockReader(max_workers=config.num_workers, verify_checksums=True) - self._writer = DirectBlockWriter(max_workers=config.num_workers, direct_on_block_devices=True) - - # Tasks and their per-key work use separate pools, so a task waiting on its keys can't - # occupy the thread they need. Each direction has its own, so slow commits can't delay reads. - self._lookup_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-lookup") - self._store_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-store") - self._load_tasks = ThreadPoolExecutor(2, thread_name_prefix="hc-l2-load") - self._store_keys = ThreadPoolExecutor(config.num_workers, thread_name_prefix="hc-l2-store-key") - self._load_keys = ThreadPoolExecutor(config.num_workers, thread_name_prefix="hc-l2-load-key") - - # Event fds - - def get_store_event_fd(self) -> int: - return self._store_efd.fileno() - - def get_lookup_and_lock_event_fd(self) -> int: - return self._lookup_efd.fileno() - - def get_load_event_fd(self) -> int: - return self._load_efd.fileno() - - # Store - - def submit_store_task(self, keys: list, objects: list) -> L2TaskId: - task_id = next(self._task_ids) - self._store_tasks.submit(self._run_store, list(keys), list(objects), task_id) - return task_id - - def pop_completed_store_tasks(self) -> Dict[L2TaskId, L2StoreResult]: - with self._lock: - done = self._done_store - self._done_store = {} - return done - - def _run_store(self, keys: list, objects: list, task_id: L2TaskId) -> None: - stored_keys, stored_sizes = [], [] - success = True - try: - futures = [self._store_keys.submit(self._store_one, k, o) for k, o in zip(keys, objects)] - for key, future in zip(keys, futures): - try: - size = future.result() - except Exception as e: - logger.warning("Store failed for %s: %s", self._uri(key), e) - self._count("store_failures") - success = False - continue - if size > 0: - stored_keys.append(key) - stored_sizes.append(size) - if stored_keys: - self._notify_keys_stored(stored_keys, stored_sizes) - except Exception: - logger.exception("Store task %s failed", task_id) - success = False - with self._lock: - self._done_store[task_id] = L2StoreResult(success, sum(stored_sizes)) - self._store_efd.notify() - - def _store_one(self, key: Any, obj: Any) -> int: - """Returns the bytes stored, or 0 if the object is already stored or being stored.""" - uri = self._uri(key) - with self._lock: - if uri in self._storing: - return 0 - self._storing.add(uri) - try: - client = self._client() - if self._is_valid(client.locate(uri, auto_ingest=False)): - return 0 - - view = memoryview(obj.byte_array).cast("B") - staged = client.stage_write(uri, len(view), tier=self._config.tier, auto_flush_s3=False) - if not staged.is_staged: - raise IOError(f"stage_write failed: {staged.error_message}") - try: - self._require_local_only_support(client, uri) - self._writer.write_chunks(staged.chunk_layout, view) - checksums = self._chunk_checksums(staged.chunk_layout, view) - if not client.commit_write(uri, local_only=True, chunk_checksums=checksums): - raise IOError("commit_write failed") - except Exception: - self._evict_quietly(client, uri) - raise - return len(view) - finally: - with self._lock: - self._storing.discard(uri) - - def _require_local_only_support(self, client: HyperCacheClient, uri: str) -> None: - # An older daemon ignores local_only and would upload the block to its backend, so this - # has to be settled before the first commit. Only newer daemons report status on locate. - if self._daemon_supports_local_only: - return - if client.locate(uri, auto_ingest=False).sync_status != "STAGED": - raise IOError("the HyperCache daemon has no local-only commit support; upgrade it") - self._daemon_supports_local_only = True - - @staticmethod - def _chunk_checksums(layout: list, view: memoryview) -> List[int]: - checksums = [] - position = 0 - for chunk in layout: - checksums.append(zlib.crc32(view[position : position + chunk.length]) & 0xFFFFFFFF) - position += chunk.length - return checksums - - # Lookup and lock - - def submit_lookup_and_lock_task(self, keys: list, group_layout_descs: dict) -> L2TaskId: - task_id = next(self._task_ids) - self._lookup_tasks.submit(self._run_lookup, list(keys), task_id) - return task_id - - def query_lookup_and_lock_result(self, task_id: L2TaskId) -> Optional[Bitmap]: - with self._lock: - return self._done_lookup.pop(task_id, None) - - def submit_unlock(self, keys: list) -> None: - with self._lock: - for key in keys: - uri = self._uri(key) - count = self._locks.get(uri, 0) - if count <= 1: - self._locks.pop(uri, None) - else: - self._locks[uri] = count - 1 - - def _run_lookup(self, keys: list, task_id: L2TaskId) -> None: - bitmap = Bitmap(len(keys)) - try: - client = self._client() - for i, key in enumerate(keys): - uri = self._uri(key) - if self._is_valid(client.locate(uri, auto_ingest=False)): - with self._lock: - self._locks[uri] = self._locks.get(uri, 0) + 1 - bitmap.set(i) - except Exception as e: - # Keys already locked stay reported as hits; the rest are misses - logger.warning("Lookup failed: %s", e) - with self._lock: - self._done_lookup[task_id] = bitmap - self._lookup_efd.notify() - - @staticmethod - def _is_valid(location: LocateResult) -> bool: - return ( - location.is_hit - and location.sync_status == _LOCAL_ONLY - and bool(location.chunk_layout) - and all(chunk.checksum is not None for chunk in location.chunk_layout) - ) - - # Load - - def submit_load_task(self, keys: list, objects: list) -> L2TaskId: - task_id = next(self._task_ids) - self._load_tasks.submit(self._run_load, list(keys), list(objects), task_id) - return task_id - - def query_load_result(self, task_id: L2TaskId) -> Optional[Bitmap]: - with self._lock: - return self._done_load.pop(task_id, None) - - def _run_load(self, keys: list, objects: list, task_id: L2TaskId) -> None: - bitmap = Bitmap(len(keys)) - loaded = [] - try: - futures = [self._load_keys.submit(self._load_one, k, o) for k, o in zip(keys, objects)] - for i, (key, future) in enumerate(zip(keys, futures)): - if future.result(): - bitmap.set(i) - loaded.append(key) - if loaded: - self._notify_keys_accessed(loaded) - except Exception: - logger.exception("Load task %s failed", task_id) - with self._lock: - self._done_load[task_id] = bitmap - self._load_efd.notify() - - def _load_one(self, key: Any, obj: Any) -> bool: - uri = self._uri(key) - client = None - location = None - try: - client = self._client() - location = client.locate(uri, auto_ingest=False) - if not self._is_valid(location): - return False - view = memoryview(obj.byte_array).cast("B") - if location.object_size != len(view): - logger.warning("Size mismatch for %s: stored %d, buffer %d", uri, location.object_size, len(view)) - return False - return self._reader.read_range_into(location.chunk_layout, 0, len(view), view) == len(view) - except ChecksumMismatchError as e: - logger.error("Treating %s as a miss: %s", uri, e) - self._count("checksum_failures") - self._evict_if_unchanged(client, uri, location) - return False - except Exception as e: - logger.warning("Load failed for %s: %s", uri, e) - self._count("load_failures") - return False - - def _evict_if_unchanged(self, client: HyperCacheClient, uri: str, seen: LocateResult) -> None: - # A changed generation means the block was replaced during the read, so it isn't corrupt - try: - if client.locate(uri, auto_ingest=False).generation == seen.generation: - client.evict(uri) - except Exception as e: - logger.warning("Could not evict %s: %s", uri, e) - - # Delete, status, shutdown - - def delete(self, keys: list) -> None: - deleted_keys, deleted_sizes = [], [] - client = self._client() - for key in keys: - uri = self._uri(key) - with self._lock: - if self._locks.get(uri, 0) > 0: - continue - try: - location = client.locate(uri, auto_ingest=False) - if location.is_hit and client.evict(uri): - deleted_keys.append(key) - deleted_sizes.append(location.object_size) - except Exception as e: - logger.warning("Delete failed for %s: %s", uri, e) - if deleted_keys: - self._notify_keys_deleted(deleted_keys, deleted_sizes) - - def report_status(self) -> dict: - status: Dict[str, Any] = {"is_healthy": True, "namespace": self._config.namespace} - try: - self._client().get_status() - except Exception as e: - status.update(is_healthy=False, error=str(e)) - with self._lock: - status.update(self._counters) - status["locked_keys"] = len(self._locks) - return status - - def close(self) -> None: - with self._lock: - if self._closed: - return - self._closed = True - # Tasks first, because they wait on the per-key pools - for pool in (self._lookup_tasks, self._store_tasks, self._load_tasks, self._store_keys, self._load_keys): - pool.shutdown(wait=True) - self._reader.close() - self._writer.close() - with self._lock: - clients, self._all_clients = self._all_clients, [] - for client in clients: - client.close() - self._store_efd.close() - self._lookup_efd.close() - self._load_efd.close() - - # Helpers - - def _uri(self, key: Any) -> str: - # Every field is quoted so none can add a path level. Empty and non-empty salts have - # different shapes, so no salt can collide with "no salt". - salt = f"s-{quote(key.cache_salt, safe='')}" if key.cache_salt else "_" - model = quote(key.model_name, safe="") - return ( - f"hypercache://kv_cache/{self._namespace}/{model}/{key.kv_rank:x}/" - f"{key.object_group_id:x}/{salt}/{key.chunk_hash.hex()}.kv" - ) - - def _client(self) -> HyperCacheClient: - # One per thread: a client serializes its requests, so a slow commit would block lookups - client = getattr(self._clients, "client", None) - if client is None: - client = HyperCacheClient(socket_path=self._config.socket_path, timeout=self._config.timeout_s) - self._clients.client = client - with self._lock: - self._all_clients.append(client) - return client - - def _count(self, name: str) -> None: - with self._lock: - self._counters[name] += 1 - - @staticmethod - def _evict_quietly(client: HyperCacheClient, uri: str) -> None: - try: - client.evict(uri) - except Exception as e: - logger.warning("Could not clean up %s: %s", uri, e) diff --git a/client-py/hypercache/kv_store.py b/client-py/hypercache/kv_store.py index 3714480..907ab43 100644 --- a/client-py/hypercache/kv_store.py +++ b/client-py/hypercache/kv_store.py @@ -5,7 +5,7 @@ Host RAM (`/dev/shm` / HugePages) and Tier-2 Striped NVMe engine. This is a building block for code that manages its own KV-cache blocks. For LMCache, -use `hypercache.integrations.lmcache_l2`. There is no NVIDIA Dynamo KVBM integration. +use the connector in `lmcache-connector/`. There is no NVIDIA Dynamo KVBM integration. Blocks stay on this host and remain evictable, unless write_through=True asks for a synchronous backend flush. diff --git a/client-py/pyproject.toml b/client-py/pyproject.toml index 7129672..250d7af 100644 --- a/client-py/pyproject.toml +++ b/client-py/pyproject.toml @@ -40,9 +40,6 @@ Repository = "https://github.com/looelabs/hypercache" Issues = "https://github.com/looelabs/hypercache/issues" [project.optional-dependencies] -lmcache = [ - "lmcache>=0.5.5,<0.6; python_version >= '3.10'", -] gpu = [ "kvikio-cu12>=24.0.0", "cupy-cuda12x>=12.0.0", diff --git a/client-py/tests/test_lmcache_adapter.py b/client-py/tests/test_lmcache_adapter.py deleted file mode 100644 index fd4e230..0000000 --- a/client-py/tests/test_lmcache_adapter.py +++ /dev/null @@ -1,484 +0,0 @@ -""" -Unit tests for the LMCache L2 adapter, using a fake daemon on a real socket and a real data file. - -LMCache only ships Linux wheels, so its modules are stubbed where it isn't installed. -scripts/e2e/lmcache_l2_e2e.py covers the real LMCache and the real daemon. -""" - -import importlib.util -import json -import os -import select -import shutil -import socket -import sys -import tempfile -import threading -import time -import types -import unittest -from dataclasses import dataclass - - -def _install_lmcache_stubs(): - class Bitmap: - def __init__(self, size): - self.bits = [False] * size - - def set(self, index): - self.bits[index] = True - - def test(self, index): - return self.bits[index] - - class L2StoreResult(int): - def __new__(cls, success, bytes_transferred=0): - return super().__new__(cls, bytes_transferred if success else -1) - - class L2AdapterInterface: - def __init__(self, max_capacity_bytes=0): - self.events = {"stored": [], "accessed": [], "deleted": []} - - def _notify_keys_stored(self, keys, sizes): - self.events["stored"].extend(keys) - - def _notify_keys_accessed(self, keys): - self.events["accessed"].extend(keys) - - def _notify_keys_deleted(self, keys, sizes): - self.events["deleted"].extend(keys) - - class Notifier: - def __init__(self): - self.read_fd, self.write_fd = os.pipe() - - def fileno(self): - return self.read_fd - - def notify(self): - os.write(self.write_fd, b"x") - - def close(self): - os.close(self.read_fd) - os.close(self.write_fd) - - modules = { - "lmcache": {}, - "lmcache.lmcache_native": {"Bitmap": Bitmap}, - "lmcache.v1": {}, - "lmcache.v1.platform": {"create_event_notifier": Notifier}, - "lmcache.v1.distributed": {}, - "lmcache.v1.distributed.internal_api": {"L2StoreResult": L2StoreResult}, - "lmcache.v1.distributed.l2_adapters": {}, - "lmcache.v1.distributed.l2_adapters.base": {"L2AdapterInterface": L2AdapterInterface, "L2TaskId": int}, - "lmcache.v1.distributed.l2_adapters.config": {"L2AdapterConfigBase": object}, - } - for name, attributes in modules.items(): - module = types.ModuleType(name) - module.__dict__.update(attributes) - sys.modules[name] = module - - -try: - import lmcache.v1.distributed.l2_adapters.base # noqa: F401 - - HAVE_LMCACHE = True -except ImportError: - HAVE_LMCACHE = False - _install_lmcache_stubs() - -# The adapter imports torch only to set LMCache's import order. Where torch is absent, stub it for -# this one import so that other test modules still see that it's missing. -_torch_missing = "torch" not in sys.modules and importlib.util.find_spec("torch") is None -if _torch_missing: - sys.modules["torch"] = types.ModuleType("torch") -from hypercache.integrations.lmcache_l2 import HyperCacheL2Adapter, HyperCacheL2AdapterConfig # noqa: E402 - -if _torch_missing: - del sys.modules["torch"] - -CHUNK_SIZE = 4 * 1024 * 1024 - - -@dataclass(frozen=True) -class Key: - chunk_hash: bytes - model_name: str = "org/model" - kv_rank: int = 0 - object_group_id: int = 0 - cache_salt: str = "" - - -class Obj: - def __init__(self, data): - self.byte_array = memoryview(bytearray(data)) - - -def payload(size, seed=1): - return bytes((i * seed) % 251 for i in range(4096)) * (size // 4096) + bytes(size % 4096) - - -class FakeDaemon: - """Speaks enough of the daemon protocol, with the same chunking and commit rules.""" - - def __init__(self, directory, reports_sync_status=True): - self.arena = os.path.join(directory, "arena.raw") - with open(self.arena, "wb") as f: - f.truncate(256 * 1024 * 1024) - self.socket_path = os.path.join(directory, "d.sock") - self.reports_sync_status = reports_sync_status - self.objects = {} - self.requests = [] - self.next_offset = 0 - self.generation = 0 - self.lock = threading.Lock() - self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - self.server.bind(self.socket_path) - self.server.listen(32) - threading.Thread(target=self._accept, daemon=True).start() - - def stop(self): - self.server.close() - os.unlink(self.socket_path) - - def _accept(self): - while True: - try: - conn, _ = self.server.accept() - except OSError: - return - threading.Thread(target=self._serve, args=(conn,), daemon=True).start() - - def _serve(self, conn): - with conn, conn.makefile("rb") as lines: - for line in lines: - request = json.loads(line) - with self.lock: - self.requests.append(request) - response = self._handle(request) - conn.sendall((json.dumps(response) + "\n").encode()) - - def _handle(self, r): - action, uri = r.get("action"), r.get("uri") - if action == "stage_write": - layout, left = [], r["size_bytes"] - while left > 0: - length = min(left, CHUNK_SIZE) - layout.append({"device": self.arena, "offset": self.next_offset, "length": length, "tier": "nvme"}) - self.next_offset += CHUNK_SIZE - left -= length - self.generation += 1 - self.objects[uri] = { - "size": r["size_bytes"], - "layout": layout, - "status": "STAGED", - "generation": self.generation, - } - return { - "status": "WRITESTAGED", - "object_size": r["size_bytes"], - "chunk_size": CHUNK_SIZE, - "chunk_layout": layout, - "sync_status": "STAGED", - } - if action == "commit_write": - entry = self.objects.get(uri) - if entry is None: - return {"status": "ERROR", "error_message": "not staged"} - crcs = r.get("chunk_checksums") - if crcs is not None: - if len(crcs) != len(entry["layout"]): - return {"status": "ERROR", "error_message": "bad checksum count"} - for chunk, crc in zip(entry["layout"], crcs): - chunk["checksum"] = crc - entry["status"] = "LOCAL_ONLY" if r.get("local_only") else "COMMITTED" - return {"status": "WRITECOMMITTED", "object_size": entry["size"]} - if action in ("locate", "ingest"): - entry = self.objects.get(uri) - if entry is None: - return {"status": "MISS"} - response = { - "status": "HIT", - "object_size": entry["size"], - "chunk_size": CHUNK_SIZE, - "chunk_layout": entry["layout"], - "generation": entry["generation"], - } - if self.reports_sync_status: - response["sync_status"] = entry["status"] - return response - if action == "evict": - self.objects.pop(uri, None) - return {"status": "EVICTED"} - return {"status": "PONG"} - - def actions(self, name): - with self.lock: - return [r for r in self.requests if r.get("action") == name] - - def corrupt(self, uri, chunk_index=0): - chunk = self.objects[uri]["layout"][chunk_index] - with open(self.arena, "r+b") as f: - f.seek(chunk["offset"] + 17) - byte = f.read(1) - f.seek(chunk["offset"] + 17) - f.write(bytes([byte[0] ^ 0xFF])) - - -class AdapterTestCase(unittest.TestCase): - def setUp(self): - # Short path: AF_UNIX paths have a low length limit on macOS - self.directory = tempfile.mkdtemp(prefix="hcl2", dir="/tmp") - self.daemon = FakeDaemon(self.directory) - self.adapter = self.make_adapter() - self.addCleanup(shutil.rmtree, self.directory, ignore_errors=True) - self.addCleanup(self.adapter.close) - - def make_adapter(self, namespace="ns1"): - return HyperCacheL2Adapter( - HyperCacheL2AdapterConfig(namespace=namespace, socket_path=self.daemon.socket_path, timeout_s=2) - ) - - def store(self, adapter, keys, objects): - task_id = adapter.submit_store_task(keys, objects) - deadline = time.time() + 10 - while time.time() < deadline: - select.select([adapter.get_store_event_fd()], [], [], 0.05) - done = adapter.pop_completed_store_tasks() - if task_id in done: - return done[task_id] - self.fail("store task did not finish") - - def lookup(self, adapter, keys): - task_id = adapter.submit_lookup_and_lock_task(keys, {}) - return self._wait(adapter.query_lookup_and_lock_result, task_id, len(keys)) - - def load(self, adapter, keys, objects): - task_id = adapter.submit_load_task(keys, objects) - return self._wait(adapter.query_load_result, task_id, len(keys)) - - def _wait(self, query, task_id, count): - deadline = time.time() + 10 - while time.time() < deadline: - bitmap = query(task_id) - if bitmap is not None: - self.assertIsNone(query(task_id), "results must be returned once") - return [bitmap.test(i) for i in range(count)] - time.sleep(0.005) - self.fail("task did not finish") - - def test_round_trip_across_chunks(self): - key = Key(b"\x01\x02") - data = payload(CHUNK_SIZE * 2 + 8192) - self.assertEqual(self.store(self.adapter, [key], [Obj(data)]), len(data)) - self.assertEqual(self.lookup(self.adapter, [key, Key(b"\x09")]), [True, False]) - - target = Obj(bytes(len(data))) - self.assertEqual(self.load(self.adapter, [key], [target]), [True]) - self.assertEqual(bytes(target.byte_array), data) - - commit = self.daemon.actions("commit_write")[0] - self.assertTrue(commit["local_only"]) - self.assertEqual(len(commit["chunk_checksums"]), 3) - self.assertFalse(self.daemon.actions("stage_write")[0]["auto_flush_s3"]) - - @unittest.skipIf(HAVE_LMCACHE, "inspects the stub's event log") - def test_notifies_only_real_changes(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - self.store(self.adapter, [key], [Obj(payload(8192))]) - self.assertEqual(self.adapter.events["stored"], [key]) - self.load(self.adapter, [key, Key(b"\x02")], [Obj(bytes(8192)), Obj(bytes(8192))]) - self.assertEqual(self.adapter.events["accessed"], [key]) - - def test_event_fds_are_distinct_and_fire(self): - fds = { - self.adapter.get_store_event_fd(), - self.adapter.get_lookup_and_lock_event_fd(), - self.adapter.get_load_event_fd(), - } - self.assertEqual(len(fds), 3) - self.adapter.submit_lookup_and_lock_task([Key(b"\x01")], {}) - ready, _, _ = select.select([self.adapter.get_lookup_and_lock_event_fd()], [], [], 5) - self.assertTrue(ready) - - def test_key_fields_isolate_blocks(self): - base = Key(b"\xaa", cache_salt="tenant-a") - self.store(self.adapter, [base], [Obj(payload(8192))]) - others = [ - Key(b"\xab", cache_salt="tenant-a"), - Key(b"\xaa", cache_salt="tenant-b"), - Key(b"\xaa", cache_salt=""), - Key(b"\xaa", model_name="org/other", cache_salt="tenant-a"), - Key(b"\xaa", kv_rank=1, cache_salt="tenant-a"), - Key(b"\xaa", object_group_id=1, cache_salt="tenant-a"), - ] - self.assertEqual(self.lookup(self.adapter, others), [False] * len(others)) - self.assertEqual(self.lookup(self.adapter, [base]), [True]) - - def test_no_salt_cannot_collide_with_any_salt(self): - self.store(self.adapter, [Key(b"\xaa")], [Obj(payload(8192))]) - self.assertEqual(self.lookup(self.adapter, [Key(b"\xaa", cache_salt="_")]), [False]) - - def test_model_name_cannot_add_path_levels(self): - uri = self.adapter._uri(Key(b"\x01", model_name="a/b/../c", cache_salt="x/y")) - self.assertEqual(uri.count("/"), len("hypercache://kv_cache/ns/m/r/g/s/h".split("/")) - 1) - - def test_changed_namespace_misses(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - other = self.make_adapter(namespace="ns2") - self.addCleanup(other.close) - self.assertEqual(self.lookup(other, [key]), [False]) - - def test_namespace_is_required(self): - with self.assertRaises(ValueError): - HyperCacheL2AdapterConfig.from_dict({"socket_path": "/tmp/x"}) - - def test_corrupt_block_is_a_miss_and_evicted(self): - key = Key(b"\x01") - data = payload(CHUNK_SIZE + 4096) - self.store(self.adapter, [key], [Obj(data)]) - self.daemon.corrupt(self.adapter._uri(key), chunk_index=1) - - self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(len(data)))]), [False]) - self.assertEqual(self.lookup(self.adapter, [key]), [False]) - self.assertEqual(self.adapter.report_status()["checksum_failures"], 1) - - def test_one_bad_key_does_not_fail_the_others(self): - good, bad = Key(b"\x01"), Key(b"\x02") - self.store(self.adapter, [good, bad], [Obj(payload(8192)), Obj(payload(8192, seed=3))]) - self.daemon.corrupt(self.adapter._uri(bad)) - targets = [Obj(bytes(8192)), Obj(bytes(8192))] - self.assertEqual(self.load(self.adapter, [good, bad], targets), [True, False]) - self.assertEqual(bytes(targets[0].byte_array), payload(8192)) - - def test_wrong_buffer_size_is_a_miss_and_keeps_the_block(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(4096))]), [False]) - self.assertEqual(self.lookup(self.adapter, [key]), [True]) - - def test_block_replaced_during_read_is_not_evicted(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - uri = self.adapter._uri(key) - self.daemon.corrupt(uri) - - class ReplacingReader: - def __init__(self, reader, daemon): - self.reader, self.daemon = reader, daemon - - def read_range_into(self, *args): - try: - return self.reader.read_range_into(*args) - finally: - self.daemon.objects[uri]["generation"] += 1 - - def close(self): - self.reader.close() - - self.adapter._reader = ReplacingReader(self.adapter._reader, self.daemon) - self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(8192))]), [False]) - self.assertIn(uri, self.daemon.objects) - - def test_uncommitted_and_unchecked_blocks_are_misses(self): - key = Key(b"\x01") - uri = self.adapter._uri(key) - client = self.adapter._client() - client.stage_write(uri, 8192, auto_flush_s3=False) - self.assertEqual(self.lookup(self.adapter, [key]), [False]) - self.assertEqual(self.load(self.adapter, [key], [Obj(bytes(8192))]), [False]) - - client.commit_write(uri, local_only=True) - self.assertEqual(self.lookup(self.adapter, [key]), [False], "no checksums") - - def test_interrupted_store_can_be_retried(self): - key = Key(b"\x01") - self.adapter._client().stage_write(self.adapter._uri(key), 8192, auto_flush_s3=False) - self.assertEqual(self.store(self.adapter, [key], [Obj(payload(8192))]), 8192) - self.assertEqual(self.lookup(self.adapter, [key]), [True]) - - def test_older_daemon_is_refused_before_any_write(self): - self.daemon.reports_sync_status = False - key = Key(b"\x01") - self.assertEqual(self.store(self.adapter, [key], [Obj(payload(8192))]), -1) - self.assertEqual(self.daemon.actions("commit_write"), []) - self.assertEqual(self.daemon.objects, {}) - self.assertEqual(self.lookup(self.adapter, [key]), [False]) - - def test_failed_write_fails_the_task_and_cleans_up(self): - def fail(*_): - raise OSError("disk error") - - self.adapter._writer.write_chunks = fail - self.assertEqual(self.store(self.adapter, [Key(b"\x01")], [Obj(payload(8192))]), -1) - self.assertEqual(self.daemon.objects, {}) - self.assertEqual(self.daemon.actions("commit_write"), []) - - def test_delete_skips_locked_blocks_until_unlocked(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - self.lookup(self.adapter, [key]) - self.lookup(self.adapter, [key]) - - self.adapter.delete([key]) - self.assertEqual(len(self.daemon.objects), 1) - self.adapter.submit_unlock([key]) - self.adapter.delete([key]) - self.assertEqual(len(self.daemon.objects), 1) - self.adapter.submit_unlock([key]) - self.adapter.delete([key]) - self.assertEqual(self.daemon.objects, {}) - - def test_unlock_of_unknown_key_is_harmless(self): - self.adapter.submit_unlock([Key(b"\x77")]) - self.assertEqual(self.adapter.report_status()["locked_keys"], 0) - - def test_daemon_down_means_misses_and_failed_stores(self): - key = Key(b"\x01") - self.store(self.adapter, [key], [Obj(payload(8192))]) - self.adapter.close() - self.daemon.stop() - - adapter = self.make_adapter() - self.adapter = adapter - self.addCleanup(adapter.close) - self.assertEqual(self.lookup(adapter, [key]), [False]) - self.assertEqual(self.load(adapter, [key], [Obj(bytes(8192))]), [False]) - self.assertEqual(self.store(adapter, [key], [Obj(payload(8192))]), -1) - adapter.submit_unlock([key]) - self.assertFalse(adapter.report_status()["is_healthy"]) - - def test_concurrent_stores_of_the_same_key_stay_readable(self): - key = Key(b"\x01") - objects = [Obj(payload(8192)) for _ in range(16)] - self.store(self.adapter, [key] * 16, objects) - target = Obj(bytes(8192)) - self.assertEqual(self.load(self.adapter, [key], [target]), [True]) - self.assertEqual(bytes(target.byte_array), payload(8192)) - - -class KVStoreLocalOnlyTest(unittest.TestCase): - def setUp(self): - self.directory = tempfile.mkdtemp(prefix="hckv", dir="/tmp") - self.addCleanup(shutil.rmtree, self.directory, ignore_errors=True) - self.daemon = FakeDaemon(self.directory) - - def test_commit_is_local_only_and_staged_blocks_are_misses(self): - from hypercache.kv_store import HyperCacheKVStore - - store = HyperCacheKVStore(socket_path=self.daemon.socket_path, default_tier="nvme", prefer_gds=False) - self.addCleanup(store.close) - block = payload(8192) - self.assertTrue(store.put_kv_block("committed", block)) - self.assertTrue(self.daemon.actions("commit_write")[0]["local_only"]) - self.assertEqual(bytes(store.get_kv_block("committed")), block) - - store._client.stage_write(store._make_uri("staged"), 8192) - self.assertFalse(store.exists_kv_block("staged")) - self.assertIsNone(store.get_kv_block("staged")) - - -if __name__ == "__main__": - unittest.main() diff --git a/lmcache-connector/Cargo.lock b/lmcache-connector/Cargo.lock new file mode 100644 index 0000000..96915d9 --- /dev/null +++ b/lmcache-connector/Cargo.lock @@ -0,0 +1,265 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "crc32fast" +version = "1.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f97d3416d5337d15c4b0d78c8c91df922ca143f57ec20e2d1c188333047ef04" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hypercache-lmcache-connector" +version = "0.1.0" +dependencies = [ + "crc32fast", + "libc", + "pyo3", + "serde", + "serde_json", +] + +[[package]] +name = "indoc" +version = "2.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a37b2691796cffeb8a8cd305ac66e65841559f147f4e63231d0eafa4db5384d1" +dependencies = [ + "rustversion", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "libc" +version = "0.2.191" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pyo3" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "once_cell", + "portable-atomic", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a" +dependencies = [ + "heck", + "proc-macro2", + "pyo3-build-config", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca" + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "unindent" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/lmcache-connector/Cargo.toml b/lmcache-connector/Cargo.toml new file mode 100644 index 0000000..0faea0d --- /dev/null +++ b/lmcache-connector/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "hypercache-lmcache-connector" +version = "0.1.0" +edition = "2021" +license = "Apache-2.0" +description = "LMCache native L2 connector backed by the HyperCache daemon" +publish = false + +[lib] +name = "hypercache_lmcache_native" +crate-type = ["cdylib", "rlib"] + +[features] +# Plain `cargo test` builds without Python, so the tests need no interpreter or LMCache. +python = ["dep:pyo3"] +extension-module = ["python", "pyo3/extension-module"] + +[dependencies] +crc32fast = "1" +libc = "0.2" +pyo3 = { version = "0.24", optional = true } +serde = { version = "1", features = ["derive"] } +serde_json = "1" diff --git a/lmcache-connector/README.md b/lmcache-connector/README.md new file mode 100644 index 0000000..8acfef8 --- /dev/null +++ b/lmcache-connector/README.md @@ -0,0 +1,64 @@ +# HyperCache connector for LMCache (Rust) + +Lets an LMCache MP-mode server keep KV-cache chunks on HyperCache's NVMe and RAM tiers. LMCache loads it through its `native_plugin` adapter type. Below LMCache's own wrapper, all the work runs in Rust worker threads without the Python interpreter lock. + +## Build + +Needs a Rust toolchain and maturin. Build against the Python that runs LMCache: + +```sh +cd lmcache-connector +maturin build --release -i python3.12 +pip install target/wheels/hypercache_lmcache_native-*.whl +``` + +## Use + +```json +{ + "type": "native_plugin", + "module_path": "hypercache_lmcache_native", + "class_name": "HyperCacheNativeConnector", + "adapter_params": { + "namespace": "qwen2.5-7b-awq-rev1234", + "socket_path": "/run/hypercache/hypercache.sock", + "tier": "nvme", + "num_workers": 32 + }, + "max_capacity_gb": 0 +} +``` + +| Setting | Meaning | +|---|---| +| `namespace` | Required. Must change when the model weights, dtype or engine settings change. LMCache's key has a model name but no revision, so without this a weight change could return wrong KV data. | +| `socket_path` | Daemon socket. Defaults to the same search order as the Python client. | +| `tier` | `nvme` (default) or `ram`. For `ram`, LMCache must share `/dev/shm` with the daemon. | +| `num_workers` | Objects read or written at once, per direction (default 32). On one drive, 8 is enough. | +| `timeout_s` | Daemon request timeout in seconds (default 30). Commits get at least 300. | +| `max_capacity_gb` | Keep at 0. The daemon owns capacity and evicts under pressure. | + +## Behaviour + +- Any doubt about a block is a miss. Lookup only accepts committed local-only blocks with a checksum for every chunk, and load verifies every chunk before reporting success. +- Blocks are never flushed to a backend. Against an older daemon, stores fail before any data is written and lookups miss. +- A block that fails its checksum is evicted, unless it was replaced during the read. +- On raw block devices, writes use O_DIRECT. Page-aligned L1 buffers (`--l1-align-bytes 4096`) go to and from the drive with no copy. A partial last block goes through the page cache on writes and an aligned copy on reads. + +## LMCache's wrapper + +LMCache's `NativeConnectorL2Adapter` wrapper sits between LMCache and this connector, which leads to some behaviour worth knowing. + +- **Locks.** The wrapper tracks lookup locks itself and doesn't check them before a delete, so a locked block can be deleted. The later load is a miss, never wrong data. LMCache only calls delete from global eviction, which `max_capacity_gb: 0` turns off. +- **Status.** `report_status` doesn't include this connector's counters. Checksum failures are logged to stderr, and `adapter._client.stats()` returns the counters. +- **Store accounting.** The wrapper counts bytes per key it hasn't seen in this process, so after a restart a store of an existing block reports its bytes even though nothing was written. +- **Partial store failures.** A store task with any failed key reports zero bytes, even if other keys in it were stored. + +## Test + +```sh +cargo test # no Python, LMCache or GPU needed +python3 scripts/e2e/lmcache_l2_e2e.py --socket /run/hc/hc.sock +``` + +The second needs a running daemon on a real device, and damages one stored chunk on purpose. Results are in `benchmarks/results/lmcache_rust_connector.md` and `lmcache_rust_connector_xeon.md`. diff --git a/lmcache-connector/pyproject.toml b/lmcache-connector/pyproject.toml new file mode 100644 index 0000000..452194b --- /dev/null +++ b/lmcache-connector/pyproject.toml @@ -0,0 +1,16 @@ +[build-system] +requires = ["maturin>=1.8,<2"] +build-backend = "maturin" + +[project] +name = "hypercache-lmcache-native" +description = "LMCache native L2 connector backed by the HyperCache daemon" +requires-python = ">=3.10" +license = { text = "Apache-2.0" } +dynamic = ["version"] +dependencies = [] + +[tool.maturin] +bindings = "pyo3" +module-name = "hypercache_lmcache_native" +features = ["extension-module"] diff --git a/lmcache-connector/rustfmt.toml b/lmcache-connector/rustfmt.toml new file mode 100644 index 0000000..7530651 --- /dev/null +++ b/lmcache-connector/rustfmt.toml @@ -0,0 +1 @@ +max_width = 120 diff --git a/lmcache-connector/src/connector.rs b/lmcache-connector/src/connector.rs new file mode 100644 index 0000000..e04d065 --- /dev/null +++ b/lmcache-connector/src/connector.rs @@ -0,0 +1,1248 @@ +//! The connector core: queues, worker threads and the block rules. No Python in here. +//! +//! LMCache's wrapper submits batches and must not block, so submit only queues work. Workers do +//! the I/O and report through a pollable fd. Rules: +//! +//! - Any doubt about a block is a miss. Lookup only accepts committed local-only blocks with a +//! checksum for every chunk, and load verifies every chunk before reporting success. +//! - Blocks are never flushed to a backend. If the daemon can't prove it understands local-only +//! commits, no data is written, because an older daemon would upload it. +//! - Checksum failures evict the block, unless it was replaced during the read. + +use crate::daemon::{Chunk, DaemonClient, Response}; +use crate::io::{BounceBuffer, ChunkIo, ReadError}; +use crate::key::{key_to_uri, quote}; +use std::any::Any; +use std::collections::{HashSet, VecDeque}; +use std::io; +use std::os::fd::{AsRawFd, FromRawFd, OwnedFd, RawFd}; +use std::path::PathBuf; +use std::sync::atomic::{ + AtomicBool, AtomicU64, AtomicU8, AtomicUsize, + Ordering::{Relaxed, SeqCst}, +}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread::JoinHandle; +use std::time::Duration; + +const LOOKUP_WORKERS: usize = 2; + +#[derive(Clone, Debug)] +pub struct Config { + pub namespace: String, + pub socket_path: PathBuf, + pub tier: String, + pub num_workers: usize, + pub timeout: Duration, +} + +impl Config { + pub fn validate(&self) -> Result<(), String> { + if self.namespace.is_empty() { + return Err( + "namespace is required: use a value that changes when the model weights or dtype change".into(), + ); + } + if self.tier != "nvme" && self.tier != "ram" { + return Err(format!("tier must be 'nvme' or 'ram', not '{}'", self.tier)); + } + if self.num_workers < 1 { + return Err("num_workers must be at least 1".into()); + } + if self.timeout.is_zero() { + return Err("timeout must be above zero".into()); + } + Ok(()) + } +} + +/// A caller's buffer. The submitter guarantees it stays valid and unused by anyone else until +/// its batch completes, by placing what keeps it alive in the batch's `keep_alive`. +#[derive(Clone, Copy)] +pub struct RawBuffer { + pub ptr: *mut u8, + pub len: usize, +} + +unsafe impl Send for RawBuffer {} + +impl RawBuffer { + unsafe fn as_slice<'a>(self) -> &'a [u8] { + std::slice::from_raw_parts(self.ptr, self.len) + } + + unsafe fn as_mut_slice<'a>(self) -> &'a mut [u8] { + std::slice::from_raw_parts_mut(self.ptr, self.len) + } +} + +pub struct Completion { + pub future_id: u64, + pub ok: bool, + pub error: String, + pub results: Vec, + /// Whatever kept the batch's buffers alive. The caller decides where this gets dropped, + /// which matters for Python buffers, since releasing those needs the interpreter lock. + pub keep_alive: Box, +} + +struct Batch { + future_id: u64, + remaining: AtomicUsize, + results: Vec, + first_error: Mutex>, + failed: AtomicBool, + keep_alive: Mutex>>, +} + +enum Job { + Store { + batch: Arc, + index: usize, + key: String, + buffer: RawBuffer, + }, + Load { + batch: Arc, + index: usize, + key: String, + buffer: RawBuffer, + }, + Exists { + batch: Arc, + keys: Vec, + }, + Delete { + batch: Arc, + keys: Vec, + }, +} + +struct Queue { + jobs: Mutex>, + ready: Condvar, +} + +impl Queue { + fn new() -> Self { + Queue { + jobs: Mutex::new(VecDeque::new()), + ready: Condvar::new(), + } + } + + fn push_all(&self, jobs: impl IntoIterator) { + self.jobs.lock().expect("queue lock").extend(jobs); + self.ready.notify_all(); + } +} + +#[derive(Default)] +pub struct Counters { + pub checksum_failures: AtomicU64, + pub load_failures: AtomicU64, + pub store_failures: AtomicU64, +} + +/// The fd LMCache polls: a non-blocking pipe, readable while completions are waiting. +struct Notifier { + read: OwnedFd, + write: OwnedFd, +} + +impl Notifier { + fn new() -> io::Result { + let mut fds: [RawFd; 2] = [0; 2]; + if unsafe { libc::pipe(fds.as_mut_ptr()) } != 0 { + return Err(io::Error::last_os_error()); + } + let (read, write) = unsafe { (OwnedFd::from_raw_fd(fds[0]), OwnedFd::from_raw_fd(fds[1])) }; + for fd in fds { + unsafe { + libc::fcntl(fd, libc::F_SETFL, libc::fcntl(fd, libc::F_GETFL) | libc::O_NONBLOCK); + libc::fcntl(fd, libc::F_SETFD, libc::FD_CLOEXEC); + } + } + Ok(Notifier { read, write }) + } + + fn signal(&self) { + // A full pipe is fine: it is already readable, so the poller will wake + let _ = unsafe { libc::write(self.write.as_raw_fd(), [1u8].as_ptr().cast(), 1) }; + } + + fn drain(&self) { + let mut sink = [0u8; 256]; + while unsafe { libc::read(self.read.as_raw_fd(), sink.as_mut_ptr().cast(), sink.len()) } > 0 {} + } +} + +struct Shared { + config: Config, + namespace: String, + store_queue: Queue, + load_queue: Queue, + lookup_queue: Queue, + completions: Mutex>, + notifier: Notifier, + storing: Mutex>, + local_only_confirmed: AtomicBool, + closed: AtomicBool, + io: ChunkIo, + counters: Counters, +} + +pub struct Connector { + shared: Arc, + workers: Mutex>>, + next_future: AtomicU64, + owner_pid: u32, +} + +impl Connector { + pub fn new(config: Config) -> io::Result { + config + .validate() + .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?; + let num_workers = config.num_workers; + let shared = Arc::new(Shared { + namespace: quote(&config.namespace), + config, + store_queue: Queue::new(), + load_queue: Queue::new(), + lookup_queue: Queue::new(), + completions: Mutex::new(Vec::new()), + notifier: Notifier::new()?, + storing: Mutex::new(HashSet::new()), + local_only_confirmed: AtomicBool::new(false), + closed: AtomicBool::new(false), + io: ChunkIo::new(), + counters: Counters::default(), + }); + let mut workers = Vec::new(); + for (name, count, which) in [ + ("store", num_workers, 0usize), + ("load", num_workers, 1), + ("lookup", LOOKUP_WORKERS, 2), + ] { + for index in 0..count { + let shared = shared.clone(); + workers.push( + std::thread::Builder::new() + .name(format!("hc-l2-{name}-{index}")) + .spawn(move || worker_loop(shared, which))?, + ); + } + } + Ok(Connector { + shared, + workers: Mutex::new(workers), + next_future: AtomicU64::new(1), + owner_pid: std::process::id(), + }) + } + + pub fn event_fd(&self) -> RawFd { + self.shared.notifier.read.as_raw_fd() + } + + pub fn uri(&self, key: &str) -> Result { + key_to_uri(&self.shared.namespace, key) + } + + pub fn counters(&self) -> &Counters { + &self.shared.counters + } + + pub fn io_stats(&self) -> &crate::io::IoStats { + &self.shared.io.stats + } + + fn new_batch(&self, count: usize, jobs: usize, keep_alive: Box) -> io::Result> { + if self.shared.closed.load(SeqCst) { + return Err(io::Error::other("connector is closed")); + } + // Worker threads don't survive a fork, so a child's work would never complete + if std::process::id() != self.owner_pid { + return Err(io::Error::other("connector was created in another process")); + } + let future_id = self.next_future.fetch_add(1, Relaxed); + Ok(Arc::new(Batch { + future_id, + remaining: AtomicUsize::new(jobs), + results: (0..count).map(|_| AtomicU8::new(0)).collect(), + first_error: Mutex::new(None), + failed: AtomicBool::new(false), + keep_alive: Mutex::new(Some(keep_alive)), + })) + } + + fn check_lengths(keys: &[String], buffers: &[RawBuffer]) -> io::Result<()> { + if keys.len() != buffers.len() { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "keys and buffers differ in length", + )); + } + Ok(()) + } + + /// # Safety + /// Every buffer must stay valid and unmodified until this batch's completion is drained, and + /// `keep_alive` must be what guarantees that. + pub unsafe fn submit_set( + &self, + keys: Vec, + buffers: Vec, + keep_alive: Box, + ) -> io::Result { + Self::check_lengths(&keys, &buffers)?; + let batch = self.new_batch(keys.len(), keys.len(), keep_alive)?; + let future_id = batch.future_id; + let jobs: Vec = keys + .into_iter() + .zip(buffers) + .enumerate() + .map(|(index, (key, buffer))| Job::Store { + batch: batch.clone(), + index, + key, + buffer, + }) + .collect(); + self.dispatch(&self.shared.store_queue, batch, jobs); + Ok(future_id) + } + + /// # Safety + /// Every buffer must stay valid and unused by anyone else until this batch's completion is + /// drained, and `keep_alive` must be what guarantees that. + pub unsafe fn submit_get( + &self, + keys: Vec, + buffers: Vec, + keep_alive: Box, + ) -> io::Result { + Self::check_lengths(&keys, &buffers)?; + let batch = self.new_batch(keys.len(), keys.len(), keep_alive)?; + let future_id = batch.future_id; + let jobs: Vec = keys + .into_iter() + .zip(buffers) + .enumerate() + .map(|(index, (key, buffer))| Job::Load { + batch: batch.clone(), + index, + key, + buffer, + }) + .collect(); + self.dispatch(&self.shared.load_queue, batch, jobs); + Ok(future_id) + } + + pub fn submit_exists(&self, keys: Vec) -> io::Result { + let batch = self.new_batch(keys.len(), 1, Box::new(()))?; + let future_id = batch.future_id; + let job = Job::Exists { + batch: batch.clone(), + keys, + }; + self.dispatch(&self.shared.lookup_queue, batch, vec![job]); + Ok(future_id) + } + + pub fn submit_delete(&self, keys: Vec) -> io::Result { + let batch = self.new_batch(keys.len(), 1, Box::new(()))?; + let future_id = batch.future_id; + let job = Job::Delete { + batch: batch.clone(), + keys, + }; + self.dispatch(&self.shared.lookup_queue, batch, vec![job]); + Ok(future_id) + } + + fn dispatch(&self, queue: &Queue, batch: Arc, jobs: Vec) { + if jobs.is_empty() { + batch.remaining.store(1, SeqCst); + finish_one(&self.shared, &batch); + } else { + queue.push_all(jobs); + } + } + + pub fn drain_completions(&self) -> Vec { + // Drain first. A completion pushed after the take below signals again, so none is missed. + self.shared.notifier.drain(); + std::mem::take(&mut *self.shared.completions.lock().expect("completions lock")) + } + + /// Stops the workers. Queued work fails fast, and I/O already running finishes first. After + /// this returns, no worker touches any caller's buffer. + pub fn close(&self) { + self.shared.closed.store(true, SeqCst); + for queue in [ + &self.shared.store_queue, + &self.shared.load_queue, + &self.shared.lookup_queue, + ] { + let _guard = queue.jobs.lock().expect("queue lock"); + queue.ready.notify_all(); + } + let workers = std::mem::take(&mut *self.workers.lock().expect("workers lock")); + let was_running = !workers.is_empty(); + for worker in workers { + let _ = worker.join(); + } + if was_running { + self.shared.io.sync(); + } + } +} + +impl Drop for Connector { + fn drop(&mut self) { + self.close(); + } +} + +struct Worker { + shared: Arc, + client: DaemonClient, + bounce: BounceBuffer, +} + +fn worker_loop(shared: Arc, which: usize) { + let client = DaemonClient::new(shared.config.socket_path.clone(), shared.config.timeout); + let mut worker = Worker { + shared: shared.clone(), + client, + bounce: BounceBuffer::new(), + }; + let queue = match which { + 0 => &shared.store_queue, + 1 => &shared.load_queue, + _ => &shared.lookup_queue, + }; + loop { + let job = { + let mut jobs = queue.jobs.lock().expect("queue lock"); + loop { + if let Some(job) = jobs.pop_front() { + break job; + } + if shared.closed.load(SeqCst) { + return; + } + jobs = queue.ready.wait(jobs).expect("queue lock"); + } + }; + worker.run(job); + } +} + +fn finish_one(shared: &Shared, batch: &Batch) { + if batch.remaining.fetch_sub(1, SeqCst) != 1 { + return; + } + let completion = Completion { + future_id: batch.future_id, + ok: !batch.failed.load(SeqCst), + error: batch.first_error.lock().expect("error lock").take().unwrap_or_default(), + results: batch.results.iter().map(|r| r.load(SeqCst) != 0).collect(), + keep_alive: batch + .keep_alive + .lock() + .expect("keep_alive lock") + .take() + .unwrap_or_else(|| Box::new(())), + }; + shared.completions.lock().expect("completions lock").push(completion); + shared.notifier.signal(); +} + +fn record_failure(batch: &Batch, message: String) { + batch.failed.store(true, SeqCst); + let mut first = batch.first_error.lock().expect("error lock"); + if first.is_none() { + *first = Some(message); + } +} + +/// Removes a URI from the in-flight store set, however the store ends. +struct StoreGuard<'a> { + shared: &'a Shared, + uri: &'a str, +} + +impl Drop for StoreGuard<'_> { + fn drop(&mut self) { + self.shared.storing.lock().expect("storing lock").remove(self.uri); + } +} + +fn layout_covers(layout: &[Chunk], size: usize) -> bool { + layout.iter().map(|chunk| chunk.length).sum::() == size as u64 +} + +impl Worker { + fn run(&mut self, job: Job) { + let shared = self.shared.clone(); + let closed = shared.closed.load(SeqCst); + match job { + Job::Store { + batch, + index, + key, + buffer, + } => { + let result = if closed { + Err(io::Error::other("connector is closed")) + } else { + self.store_one(&key, buffer) + }; + match result { + Ok(()) => batch.results[index].store(1, SeqCst), + Err(error) => { + shared.counters.store_failures.fetch_add(1, Relaxed); + record_failure(&batch, format!("store failed for {key}: {error}")); + } + } + finish_one(&shared, &batch); + } + Job::Load { + batch, + index, + key, + buffer, + } => { + if !closed && self.load_one(&key, buffer) { + batch.results[index].store(1, SeqCst); + } else { + record_failure(&batch, format!("load missed for {key}")); + } + finish_one(&shared, &batch); + } + Job::Exists { batch, keys } => { + if closed { + record_failure(&batch, "connector is closed".into()); + } else { + self.exists(&batch, &keys); + } + finish_one(&shared, &batch); + } + Job::Delete { batch, keys } => { + if !closed { + self.delete(&batch, &keys); + } + finish_one(&shared, &batch); + } + } + } + + fn store_one(&mut self, key: &str, buffer: RawBuffer) -> io::Result<()> { + let shared = self.shared.clone(); + let uri = shared.uri_for(key)?; + if buffer.len == 0 { + return Err(io::Error::other("empty object")); + } + if !shared.storing.lock().expect("storing lock").insert(uri.clone()) { + return Ok(()); // already being stored + } + let _guard = StoreGuard { + shared: &shared, + uri: &uri, + }; + + if self.client.locate(&uri)?.is_valid_block() { + return Ok(()); + } + let staged = self.client.stage_write(&uri, buffer.len as u64, &shared.config.tier)?; + let result = self.write_and_commit(&uri, staged.layout(), buffer); + if result.is_err() { + if let Err(error) = self.client.evict(&uri) { + eprintln!("hypercache connector: could not clean up {uri}: {error}"); + } + } + result + } + + fn write_and_commit(&mut self, uri: &str, layout: &[Chunk], buffer: RawBuffer) -> io::Result<()> { + self.require_local_only_support(uri)?; + if !layout_covers(layout, buffer.len) { + return Err(io::Error::other("staged layout does not match the object size")); + } + let source = unsafe { buffer.as_slice() }; + let mut checksums = Vec::with_capacity(layout.len()); + let mut position = 0; + for chunk in layout { + let data = &source[position..position + chunk.length as usize]; + self.shared.io.write_chunk(chunk, data, &mut self.bounce)?; + checksums.push(crc32fast::hash(data)); + position += chunk.length as usize; + } + self.client.commit_local_only(uri, &checksums) + } + + /// An older daemon ignores local_only and would upload the block to its backend, so this is + /// settled before the first commit. Only newer daemons report status on locate. + fn require_local_only_support(&mut self, uri: &str) -> io::Result<()> { + if self.shared.local_only_confirmed.load(SeqCst) { + return Ok(()); + } + if self.client.locate(uri)?.sync_status.as_deref() != Some("STAGED") { + return Err(io::Error::other( + "the HyperCache daemon has no local-only commit support; upgrade it", + )); + } + self.shared.local_only_confirmed.store(true, SeqCst); + Ok(()) + } + + fn load_one(&mut self, key: &str, buffer: RawBuffer) -> bool { + let shared = self.shared.clone(); + let Ok(uri) = shared.uri_for(key) else { + shared.counters.load_failures.fetch_add(1, Relaxed); + return false; + }; + let location = match self.client.locate(&uri) { + Ok(location) => location, + Err(error) => { + eprintln!("hypercache connector: load failed for {uri}: {error}"); + shared.counters.load_failures.fetch_add(1, Relaxed); + return false; + } + }; + if !location.is_valid_block() { + return false; + } + if location.object_size != Some(buffer.len as u64) || !layout_covers(location.layout(), buffer.len) { + eprintln!( + "hypercache connector: size mismatch for {uri}: buffer is {} bytes", + buffer.len + ); + return false; + } + let target = unsafe { buffer.as_mut_slice() }; + let mut position = 0; + for chunk in location.layout() { + let length = chunk.length as usize; + match shared + .io + .read_chunk(chunk, &mut target[position..position + length], &mut self.bounce) + { + Ok(()) => position += length, + Err(ReadError::Checksum(mismatch)) => { + eprintln!( + "hypercache connector: treating {uri} as a miss: CRC32 at {}+{}: expected {:08x}, got {:08x}", + chunk.device, chunk.offset, mismatch.expected, mismatch.actual + ); + shared.counters.checksum_failures.fetch_add(1, Relaxed); + self.evict_if_unchanged(&uri, &location); + return false; + } + Err(ReadError::Io(error)) => { + eprintln!("hypercache connector: load failed for {uri}: {error}"); + shared.counters.load_failures.fetch_add(1, Relaxed); + return false; + } + } + } + true + } + + /// A changed generation means the block was replaced during the read, so it isn't corrupt. + fn evict_if_unchanged(&mut self, uri: &str, seen: &Response) { + let current = self.client.locate(uri).map(|location| location.generation); + let result = match current { + Ok(generation) if generation == seen.generation => self.client.evict(uri).map(|_| ()), + Ok(_) => Ok(()), + Err(error) => Err(error), + }; + if let Err(error) = result { + eprintln!("hypercache connector: could not evict {uri}: {error}"); + } + } + + /// A daemon failure fails the whole batch, which LMCache treats as all misses. + fn exists(&mut self, batch: &Batch, keys: &[String]) { + let shared = self.shared.clone(); + for (index, key) in keys.iter().enumerate() { + let Ok(uri) = shared.uri_for(key) else { continue }; + match self.client.locate(&uri) { + Ok(location) if location.is_valid_block() => batch.results[index].store(1, SeqCst), + Ok(_) => {} + Err(error) => { + record_failure(batch, format!("lookup failed: {error}")); + return; + } + } + } + } + + fn delete(&mut self, batch: &Batch, keys: &[String]) { + let shared = self.shared.clone(); + for (index, key) in keys.iter().enumerate() { + let Ok(uri) = shared.uri_for(key) else { continue }; + let deleted = self.client.locate(&uri).and_then(|location| { + if location.status == "HIT" { + self.client.evict(&uri) + } else { + Ok(false) + } + }); + match deleted { + Ok(true) => batch.results[index].store(1, SeqCst), + Ok(false) => {} + Err(error) => eprintln!("hypercache connector: delete failed for {uri}: {error}"), + } + } + } +} + +impl Shared { + fn uri_for(&self, key: &str) -> io::Result { + key_to_uri(&self.namespace, key).map_err(io::Error::other) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::{json, Value}; + use std::collections::HashMap; + use std::io::{BufRead, BufReader, Write}; + use std::os::unix::fs::FileExt; + use std::os::unix::net::UnixListener; + use std::path::Path; + use std::time::Instant; + + const CHUNK: u64 = 4 * 1024 * 1024; + + #[derive(Clone)] + struct Stored { + layout: Vec, + size: u64, + generation: u64, + status: &'static str, + } + + #[derive(Default)] + struct DaemonState { + objects: HashMap, + next_offset: u64, + commits: usize, + requests: usize, + requested_flush: usize, + } + + /// Speaks the real wire format with file-backed storage. + struct FakeDaemon { + socket: PathBuf, + device: PathBuf, + state: Arc>, + /// An older daemon reports no sync_status on locate + legacy: bool, + } + + impl FakeDaemon { + fn start(name: &str, legacy: bool) -> FakeDaemon { + let dir = std::env::temp_dir().join(format!("hc-conn-{}-{name}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + let device = dir.join("device.bin"); + std::fs::File::create(&device) + .unwrap() + .set_len(256 * 1024 * 1024) + .unwrap(); + let socket = dir.join("d.sock"); + let listener = UnixListener::bind(&socket).unwrap(); + let state = Arc::new(Mutex::new(DaemonState::default())); + let daemon = FakeDaemon { + socket, + device: device.clone(), + state: state.clone(), + legacy, + }; + std::thread::spawn(move || { + for stream in listener.incoming() { + let stream = stream.unwrap(); + let state = state.clone(); + let device = device.clone(); + std::thread::spawn(move || serve(stream, state, device, legacy)); + } + }); + daemon + } + + fn connector(&self, namespace: &str) -> Connector { + Connector::new(Config { + namespace: namespace.into(), + socket_path: self.socket.clone(), + tier: "nvme".into(), + num_workers: 4, + timeout: Duration::from_secs(5), + }) + .unwrap() + } + } + + impl Drop for FakeDaemon { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(self.device.parent().unwrap()); + } + } + + fn serve(stream: std::os::unix::net::UnixStream, state: Arc>, device: PathBuf, legacy: bool) { + let mut writer = stream.try_clone().unwrap(); + for line in BufReader::new(stream).lines() { + let Ok(line) = line else { return }; + let request: Value = serde_json::from_str(&line).unwrap(); + let response = handle(&request, &state, &device, legacy); + writer.write_all(format!("{response}\n").as_bytes()).unwrap(); + } + } + + fn handle(request: &Value, state: &Mutex, device: &Path, legacy: bool) -> Value { + let mut state = state.lock().unwrap(); + state.requests += 1; + let uri = request["uri"].as_str().unwrap_or_default().to_string(); + match request["action"].as_str().unwrap() { + "locate" => match state.objects.get(&uri) { + None => json!({"status": "MISS"}), + Some(o) if o.status == "STAGED" => { + if legacy { + json!({"status": "MISS"}) + } else { + json!({"status": "MISS", "sync_status": "STAGED"}) + } + } + Some(o) => json!({ + "status": "HIT", "object_size": o.size, "chunk_layout": o.layout, + "generation": o.generation, "sync_status": o.status, + }), + }, + "stage_write" => { + let size = request["size_bytes"].as_u64().unwrap(); + if request["auto_flush_s3"].as_bool() != Some(false) { + state.requested_flush += 1; + } + let mut layout = Vec::new(); + let mut remaining = size; + while remaining > 0 { + let length = remaining.min(CHUNK); + let offset = state.next_offset; + state.next_offset += CHUNK; + layout.push(json!({ + "tier": "nvme", "device": device.to_str().unwrap(), "offset": offset, "length": length, + })); + remaining -= length; + } + let generation = state.next_offset; + state.objects.insert( + uri, + Stored { + layout: layout.clone(), + size, + generation, + status: "STAGED", + }, + ); + json!({"status": "WRITESTAGED", "object_size": size, "chunk_layout": layout}) + } + "commit_write" => { + let local_only = request["local_only"].as_bool().unwrap_or(false); + let checksums = request["chunk_checksums"].as_array().cloned().unwrap_or_default(); + state.commits += 1; + let Some(object) = state.objects.get_mut(&uri) else { + return json!({"status": "ERROR", "error_message": "not staged"}); + }; + for (chunk, checksum) in object.layout.iter_mut().zip(&checksums) { + chunk["checksum"] = checksum.clone(); + } + object.status = if local_only { "LOCAL_ONLY" } else { "COMMITTED" }; + json!({"status": "WRITECOMMITTED"}) + } + "evict" => { + if state.objects.remove(&uri).is_some() { + json!({"status": "EVICTED"}) + } else { + json!({"status": "ERROR", "error_message": "no such object"}) + } + } + other => panic!("unexpected action {other}"), + } + } + + /// A page-aligned test buffer. + struct Aligned { + storage: Vec, + start: usize, + len: usize, + } + + impl Aligned { + fn new(data: &[u8]) -> Aligned { + let mut storage = vec![0u8; data.len() + 4096]; + let start = (4096 - storage.as_ptr() as usize % 4096) % 4096; + storage[start..start + data.len()].copy_from_slice(data); + Aligned { + storage, + start, + len: data.len(), + } + } + + fn raw(&mut self) -> RawBuffer { + RawBuffer { + ptr: self.storage[self.start..].as_mut_ptr(), + len: self.len, + } + } + + fn bytes(&self) -> &[u8] { + &self.storage[self.start..self.start + self.len] + } + } + + fn pattern(length: usize, seed: u8) -> Vec { + (0..length).map(|i| ((i / 7) as u8).wrapping_add(seed)).collect() + } + + fn key(n: u8) -> String { + format!("Qwen/test@00000000@0@{n:02x}ab") + } + + fn wait(connector: &Connector, future_id: u64) -> Completion { + let deadline = Instant::now() + Duration::from_secs(30); + let mut pending = Vec::new(); + loop { + pending.extend(connector.drain_completions()); + if let Some(position) = pending.iter().position(|c| c.future_id == future_id) { + return pending.swap_remove(position); + } + assert!(Instant::now() < deadline, "timed out waiting for {future_id}"); + std::thread::sleep(Duration::from_millis(1)); + } + } + + fn store(connector: &Connector, keys: &[String], buffers: &mut [Aligned]) -> Completion { + let raws: Vec = buffers.iter_mut().map(|b| b.raw()).collect(); + let id = unsafe { connector.submit_set(keys.to_vec(), raws, Box::new(())) }.unwrap(); + wait(connector, id) + } + + fn load(connector: &Connector, keys: &[String], buffers: &mut [Aligned]) -> Completion { + let raws: Vec = buffers.iter_mut().map(|b| b.raw()).collect(); + let id = unsafe { connector.submit_get(keys.to_vec(), raws, Box::new(())) }.unwrap(); + wait(connector, id) + } + + fn exists(connector: &Connector, keys: &[String]) -> Vec { + let id = connector.submit_exists(keys.to_vec()).unwrap(); + wait(connector, id).results + } + + const SIZE: usize = 14 * 1024 * 1024 + 123; + + #[test] + fn round_trip_with_partial_last_block() { + let daemon = FakeDaemon::start("roundtrip", false); + let connector = daemon.connector("ns"); + let keys: Vec = (0..4).map(key).collect(); + let datas: Vec> = (0..4).map(|i| pattern(SIZE, i)).collect(); + let mut sources: Vec = datas.iter().map(|d| Aligned::new(d)).collect(); + let done = store(&connector, &keys, &mut sources); + assert!(done.ok, "{}", done.error); + assert_eq!(done.results, [true; 4]); + + let mut query = keys.clone(); + query.push(key(99)); + assert_eq!(exists(&connector, &query), [true, true, true, true, false]); + + let mut targets: Vec = (0..4).map(|_| Aligned::new(&vec![0u8; SIZE])).collect(); + let done = load(&connector, &keys, &mut targets); + assert!(done.ok, "{}", done.error); + for (target, data) in targets.iter().zip(&datas) { + assert_eq!(target.bytes(), &data[..]); + } + let state = daemon.state.lock().unwrap(); + assert_eq!(state.requested_flush, 0, "must never ask for a backend flush"); + } + + #[test] + fn repeat_store_writes_nothing() { + let daemon = FakeDaemon::start("repeat", false); + let connector = daemon.connector("ns"); + let keys = vec![key(1)]; + let mut source = vec![Aligned::new(&pattern(SIZE, 1))]; + assert!(store(&connector, &keys, &mut source).ok); + let commits = daemon.state.lock().unwrap().commits; + assert!(store(&connector, &keys, &mut source).ok); + assert_eq!(daemon.state.lock().unwrap().commits, commits); + } + + #[test] + fn older_daemon_gets_no_data_and_no_commit() { + let daemon = FakeDaemon::start("legacy", true); + assert!(daemon.legacy); + let connector = daemon.connector("ns"); + let keys = vec![key(1)]; + let data = pattern(SIZE, 1); + let mut source = vec![Aligned::new(&data)]; + let done = store(&connector, &keys, &mut source); + assert!(!done.ok); + assert!(done.error.contains("local-only"), "{}", done.error); + let state = daemon.state.lock().unwrap(); + assert_eq!(state.commits, 0); + assert!(state.objects.is_empty(), "the staged object must be cleaned up"); + let on_disk = std::fs::read(&daemon.device).unwrap(); + assert!(on_disk[..4096].iter().all(|&b| b == 0), "no data may reach the device"); + assert_eq!(connector.counters().store_failures.load(Relaxed), 1); + } + + #[test] + fn corrupt_block_is_a_miss_and_is_evicted() { + let daemon = FakeDaemon::start("corrupt", false); + let connector = daemon.connector("ns"); + let keys = vec![key(1), key(2)]; + let mut sources = vec![Aligned::new(&pattern(SIZE, 1)), Aligned::new(&pattern(SIZE, 2))]; + assert!(store(&connector, &keys, &mut sources).ok); + + // Damage the first object's last chunk + let uri = connector.uri(&keys[0]).unwrap(); + let (device, offset) = { + let state = daemon.state.lock().unwrap(); + let last = state.objects[&uri].layout.last().unwrap().clone(); + ( + last["device"].as_str().unwrap().to_string(), + last["offset"].as_u64().unwrap(), + ) + }; + std::fs::OpenOptions::new() + .write(true) + .open(device) + .unwrap() + .write_all_at(&[0xEE], offset + 9) + .unwrap(); + + let mut targets = vec![Aligned::new(&vec![0u8; SIZE]), Aligned::new(&vec![0u8; SIZE])]; + let done = load(&connector, &keys, &mut targets); + assert_eq!(done.results, [false, true]); + assert!(!done.ok); + assert_eq!(connector.counters().checksum_failures.load(Relaxed), 1); + assert_eq!(exists(&connector, &keys), [false, true]); + } + + #[test] + fn replaced_block_is_not_evicted_after_a_checksum_failure() { + let daemon = FakeDaemon::start("generation", false); + let connector = daemon.connector("ns"); + let keys = vec![key(1)]; + let mut sources = vec![Aligned::new(&pattern(SIZE, 1))]; + assert!(store(&connector, &keys, &mut sources).ok); + let uri = connector.uri(&keys[0]).unwrap(); + let seen = { + let state = daemon.state.lock().unwrap(); + let o = &state.objects[&uri]; + json!({"status": "HIT", "generation": o.generation - 1}) + }; + let seen: Response = serde_json::from_value(seen).unwrap(); + let mut worker = Worker { + shared: connector.shared.clone(), + client: DaemonClient::new(daemon.socket.clone(), Duration::from_secs(5)), + bounce: BounceBuffer::new(), + }; + worker.evict_if_unchanged(&uri, &seen); + assert_eq!(exists(&connector, &keys), [true], "a replaced block must survive"); + } + + #[test] + fn wrong_buffer_size_is_a_miss_and_leaves_the_block() { + let daemon = FakeDaemon::start("size", false); + let connector = daemon.connector("ns"); + let keys = vec![key(1)]; + let mut sources = vec![Aligned::new(&pattern(SIZE, 1))]; + assert!(store(&connector, &keys, &mut sources).ok); + let mut wrong = vec![Aligned::new(&vec![7u8; SIZE - 4096])]; + let done = load(&connector, &keys, &mut wrong); + assert_eq!(done.results, [false]); + assert!( + wrong[0].bytes().iter().all(|&b| b == 7), + "the buffer must not be touched" + ); + assert_eq!(exists(&connector, &keys), [true]); + } + + #[test] + fn staged_or_uncommitted_blocks_are_misses() { + let daemon = FakeDaemon::start("staged", false); + let connector = daemon.connector("ns"); + let uri = connector.uri(&key(1)).unwrap(); + let chunk = json!({"tier": "nvme", "device": "/x", "offset": 0, "length": 8, "checksum": 1}); + let no_sum = json!({"tier": "nvme", "device": "/x", "offset": 0, "length": 8}); + for (status, layout) in [ + ("COMMITTED", vec![chunk.clone()]), + ("LOCAL_ONLY", vec![]), + ("LOCAL_ONLY", vec![no_sum]), + ] { + daemon.state.lock().unwrap().objects.insert( + uri.clone(), + Stored { + layout, + size: 8, + generation: 1, + status, + }, + ); + assert_eq!(exists(&connector, &[key(1)]), [false], "{status}"); + } + } + + #[test] + fn namespace_and_salt_isolate_blocks() { + let daemon = FakeDaemon::start("isolate", false); + let connector = daemon.connector("a"); + let mut sources = vec![Aligned::new(&pattern(SIZE, 1))]; + assert!(store(&connector, &[key(1)], &mut sources).ok); + assert_eq!(exists(&daemon.connector("b"), &[key(1)]), [false]); + assert_eq!(exists(&connector, &[format!("{}@tenant", key(1))]), [false]); + } + + #[test] + fn malformed_key_is_a_miss_on_every_path() { + let daemon = FakeDaemon::start("badkey", false); + let connector = daemon.connector("ns"); + let bad = vec!["no-separators".to_string()]; + assert_eq!(exists(&connector, &bad), [false]); + let mut buffers = vec![Aligned::new(&vec![1u8; 4096])]; + assert_eq!(load(&connector, &bad, &mut buffers).results, [false]); + assert!(!store(&connector, &bad, &mut buffers).ok); + } + + #[test] + fn unreachable_daemon_is_a_failed_batch_then_recovers() { + let daemon = FakeDaemon::start("down", false); + let connector = Connector::new(Config { + namespace: "ns".into(), + socket_path: "/nonexistent/socket".into(), + tier: "nvme".into(), + num_workers: 1, + timeout: Duration::from_secs(1), + }) + .unwrap(); + let id = connector.submit_exists(vec![key(1)]).unwrap(); + let done = wait(&connector, id); + assert!(!done.ok); + assert_eq!(done.results, [false]); + let mut buffers = vec![Aligned::new(&vec![0u8; 4096])]; + assert_eq!(load(&connector, &[key(1)], &mut buffers).results, [false]); + drop(daemon); + } + + #[test] + fn delete_removes_only_existing_blocks() { + let daemon = FakeDaemon::start("delete", false); + let connector = daemon.connector("ns"); + let mut sources = vec![Aligned::new(&pattern(SIZE, 1))]; + assert!(store(&connector, &[key(1)], &mut sources).ok); + let id = connector.submit_delete(vec![key(1), key(2)]).unwrap(); + assert_eq!(wait(&connector, id).results, [true, false]); + assert_eq!(exists(&connector, &[key(1)]), [false]); + } + + #[test] + fn fd_becomes_readable_and_is_drained() { + let daemon = FakeDaemon::start("poll", false); + let connector = daemon.connector("ns"); + let poll_once = |timeout_ms| { + let mut fds = libc::pollfd { + fd: connector.event_fd(), + events: libc::POLLIN, + revents: 0, + }; + unsafe { libc::poll(&mut fds, 1, timeout_ms) } + }; + assert_eq!(poll_once(0), 0); + connector.submit_exists(vec![key(1)]).unwrap(); + assert_eq!(poll_once(5000), 1); + assert_eq!(connector.drain_completions().len(), 1); + assert_eq!(poll_once(0), 0, "a drained fd must not keep waking the poller"); + } + + #[test] + fn empty_batches_complete_at_once() { + let daemon = FakeDaemon::start("empty", false); + let connector = daemon.connector("ns"); + let id = connector.submit_exists(vec![]).unwrap(); + let done = wait(&connector, id); + assert!(done.ok && done.results.is_empty()); + } + + #[test] + fn close_stops_workers_and_refuses_new_work() { + let daemon = FakeDaemon::start("close", false); + let connector = daemon.connector("ns"); + let mut sources: Vec = (0..16).map(|i| Aligned::new(&pattern(1 << 20, i))).collect(); + let keys: Vec = (0..16).map(key).collect(); + let raws: Vec = sources.iter_mut().map(|b| b.raw()).collect(); + let id = unsafe { connector.submit_set(keys, raws, Box::new(())) }.unwrap(); + connector.close(); + connector.close(); + let finished = connector.drain_completions(); + assert_eq!(finished.len(), 1, "queued work must still complete"); + assert_eq!(finished[0].future_id, id); + assert!(connector.submit_exists(vec![key(1)]).is_err()); + } + + #[test] + fn keep_alive_comes_back_with_the_completion() { + let daemon = FakeDaemon::start("keep", false); + let connector = daemon.connector("ns"); + let marker = Arc::new(()); + let mut sources = [Aligned::new(&pattern(4096, 1))]; + let raws: Vec = sources.iter_mut().map(|b| b.raw()).collect(); + let id = unsafe { connector.submit_set(vec![key(1)], raws, Box::new(marker.clone())) }.unwrap(); + let done = wait(&connector, id); + assert_eq!(Arc::strong_count(&marker), 2, "workers must not drop it"); + drop(done); + assert_eq!(Arc::strong_count(&marker), 1); + } + + #[test] + fn bad_config_is_refused() { + let base = Config { + namespace: "ns".into(), + socket_path: "/x".into(), + tier: "nvme".into(), + num_workers: 1, + timeout: Duration::from_secs(1), + }; + assert!(base.validate().is_ok()); + assert!(Config { + namespace: String::new(), + ..base.clone() + } + .validate() + .is_err()); + assert!(Config { + tier: "s3".into(), + ..base.clone() + } + .validate() + .is_err()); + assert!(Config { + num_workers: 0, + ..base.clone() + } + .validate() + .is_err()); + assert!(Config { + timeout: Duration::ZERO, + ..base + } + .validate() + .is_err()); + } +} diff --git a/lmcache-connector/src/daemon.rs b/lmcache-connector/src/daemon.rs new file mode 100644 index 0000000..05a1c20 --- /dev/null +++ b/lmcache-connector/src/daemon.rs @@ -0,0 +1,169 @@ +//! Minimal client for the daemon's JSON-lines socket. One per worker thread, so a slow commit on +//! one connection can't hold up the others. + +use serde::Deserialize; +use serde_json::{json, Value}; +use std::io::{self, BufRead, BufReader, Write}; +use std::os::unix::net::UnixStream; +use std::path::PathBuf; +use std::time::Duration; + +#[derive(Debug, Clone, Deserialize)] +pub struct Chunk { + #[serde(default = "default_tier")] + pub tier: String, + pub device: String, + pub offset: u64, + pub length: u64, + #[serde(default)] + pub checksum: Option, +} + +fn default_tier() -> String { + "nvme".to_string() +} + +impl Chunk { + pub fn is_ram(&self) -> bool { + self.tier.eq_ignore_ascii_case("ram") + } + + pub fn is_shm(&self) -> bool { + self.is_ram() || self.device.ends_with(".shm") + } +} + +#[derive(Debug, Default, Deserialize)] +pub struct Response { + #[serde(default)] + pub status: String, + #[serde(default)] + pub object_size: Option, + #[serde(default)] + pub chunk_layout: Option>, + #[serde(default)] + pub generation: Option, + #[serde(default)] + pub sync_status: Option, + #[serde(default)] + pub error_message: Option, +} + +impl Response { + pub fn layout(&self) -> &[Chunk] { + self.chunk_layout.as_deref().unwrap_or(&[]) + } + + /// True only for a committed local-only block with a checksum on every chunk. Anything else + /// could be stale, unverifiable or on its way to a backend, so it counts as a miss. + pub fn is_valid_block(&self) -> bool { + self.status == "HIT" + && self.sync_status.as_deref() == Some("LOCAL_ONLY") + && !self.layout().is_empty() + && self.layout().iter().all(|chunk| chunk.checksum.is_some()) + } + + fn message(&self) -> &str { + self.error_message.as_deref().unwrap_or("unknown error") + } +} + +pub struct DaemonClient { + socket_path: PathBuf, + timeout: Duration, + commit_timeout: Duration, + stream: Option>, + line: String, +} + +impl DaemonClient { + pub fn new(socket_path: PathBuf, timeout: Duration) -> Self { + // The daemon syncs the device during a commit, which can take longer than a lookup + let commit_timeout = timeout.max(Duration::from_secs(300)); + DaemonClient { + socket_path, + timeout, + commit_timeout, + stream: None, + line: String::new(), + } + } + + fn request(&mut self, body: &Value, timeout: Duration) -> io::Result { + let result = self.exchange(body, timeout); + if result.is_err() { + // A timeout or reset leaves the stream at an unknown position: start clean next time + self.stream = None; + } + result + } + + fn exchange(&mut self, body: &Value, timeout: Duration) -> io::Result { + if self.stream.is_none() { + self.stream = Some(BufReader::new(UnixStream::connect(&self.socket_path)?)); + } + let reader = self.stream.as_mut().expect("connected above"); + reader.get_ref().set_read_timeout(Some(timeout))?; + reader.get_ref().set_write_timeout(Some(timeout))?; + + let mut message = serde_json::to_vec(body)?; + message.push(b'\n'); + reader.get_mut().write_all(&message)?; + + loop { + self.line.clear(); + if reader.read_line(&mut self.line)? == 0 { + return Err(io::Error::new( + io::ErrorKind::UnexpectedEof, + "daemon closed the connection", + )); + } + if !self.line.trim().is_empty() { + return Ok(serde_json::from_str(&self.line)?); + } + } + } + + pub fn locate(&mut self, uri: &str) -> io::Result { + let body = json!({"action": "locate", "uri": uri, "auto_ingest": false, "pinned": false}); + self.request(&body, self.timeout) + } + + pub fn stage_write(&mut self, uri: &str, size: u64, tier: &str) -> io::Result { + let body = json!({ + "action": "stage_write", + "uri": uri, + "size_bytes": size, + "tier": tier, + "is_leader": false, + "auto_flush_s3": false, + "write_through": false, + "pinned": false, + }); + let response = self.request(&body, self.timeout)?; + if response.status != "WRITESTAGED" && response.status != "WRITE_STAGED" { + return Err(io::Error::other(format!("stage_write failed: {}", response.message()))); + } + Ok(response) + } + + pub fn commit_local_only(&mut self, uri: &str, checksums: &[u32]) -> io::Result<()> { + let body = json!({ + "action": "commit_write", + "uri": uri, + "write_through": false, + "local_only": true, + "chunk_checksums": checksums, + }); + let response = self.request(&body, self.commit_timeout)?; + if response.status != "WRITECOMMITTED" && response.status != "WRITE_COMMITTED" { + return Err(io::Error::other(format!("commit_write failed: {}", response.message()))); + } + Ok(()) + } + + pub fn evict(&mut self, uri: &str) -> io::Result { + let response = self.request(&json!({"action": "evict", "uri": uri}), self.timeout)?; + Ok(matches!(response.status.as_str(), "EVICTED" | "PONG" | "OK")) + } +} diff --git a/lmcache-connector/src/io.rs b/lmcache-connector/src/io.rs new file mode 100644 index 0000000..9636b69 --- /dev/null +++ b/lmcache-connector/src/io.rs @@ -0,0 +1,564 @@ +//! Chunk reads and writes. +//! +//! O_DIRECT is used whenever the buffer, offset and length allow it, straight to and from the +//! caller's buffer. Writes use it on raw block devices only. Whatever O_DIRECT can't take, such as +//! a partial last block, goes through the page cache, so a write never fails because of it. +//! Callers must still commit, because the daemon's sync is what makes the data durable. + +use crate::daemon::Chunk; +use std::alloc::{alloc_zeroed, dealloc, Layout}; +use std::collections::HashMap; +use std::fs::{File, OpenOptions}; +use std::io::{self, Write}; +#[cfg(target_os = "linux")] +use std::os::unix::fs::OpenOptionsExt; +use std::os::unix::fs::{FileExt, FileTypeExt}; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicU64, Ordering::Relaxed}; +use std::sync::{Arc, RwLock}; + +const DEFAULT_BLOCK_SIZE: usize = 4096; +/// Alignment of the bounce buffer. A device with larger blocks simply skips O_DIRECT. +const BOUNCE_ALIGN: usize = 4096; + +/// A chunk's data did not match its recorded CRC32. +#[derive(Debug)] +pub struct ChecksumMismatch { + pub expected: u32, + pub actual: u32, +} + +#[derive(Debug)] +pub enum ReadError { + Io(io::Error), + Checksum(ChecksumMismatch), +} + +impl From for ReadError { + fn from(error: io::Error) -> Self { + ReadError::Io(error) + } +} + +#[derive(Default)] +pub struct IoStats { + /// Bytes moved by O_DIRECT straight to or from the caller's buffer + pub direct_read_bytes: AtomicU64, + pub direct_write_bytes: AtomicU64, + /// Bytes moved by O_DIRECT through an aligned copy + pub bounced_read_bytes: AtomicU64, + pub bounced_write_bytes: AtomicU64, + /// Bytes that went through the page cache + pub buffered_read_bytes: AtomicU64, + pub buffered_write_bytes: AtomicU64, +} + +/// A page-aligned buffer owned by one worker, grown on demand. +pub struct BounceBuffer { + ptr: *mut u8, + capacity: usize, +} + +// The pointer is owned, and only the worker holding the buffer uses it +unsafe impl Send for BounceBuffer {} + +impl Default for BounceBuffer { + fn default() -> Self { + Self::new() + } +} + +impl BounceBuffer { + pub fn new() -> Self { + BounceBuffer { + ptr: std::ptr::null_mut(), + capacity: 0, + } + } + + fn slice(&mut self, length: usize) -> io::Result<&mut [u8]> { + if length > self.capacity { + self.release(); + let layout = Layout::from_size_align(length, BOUNCE_ALIGN).map_err(io::Error::other)?; + let ptr = unsafe { alloc_zeroed(layout) }; + if ptr.is_null() { + return Err(io::Error::from(io::ErrorKind::OutOfMemory)); + } + self.ptr = ptr; + self.capacity = length; + } + Ok(unsafe { std::slice::from_raw_parts_mut(self.ptr, length) }) + } + + fn release(&mut self) { + if !self.ptr.is_null() { + let layout = Layout::from_size_align(self.capacity, BOUNCE_ALIGN).expect("valid when allocated"); + unsafe { dealloc(self.ptr, layout) }; + self.ptr = std::ptr::null_mut(); + self.capacity = 0; + } + } +} + +impl Drop for BounceBuffer { + fn drop(&mut self) { + self.release(); + } +} + +struct ReadFds { + buffered: File, + direct: Option, + block_size: usize, +} + +struct WriteFds { + buffered: File, + direct: Option, + block_size: usize, +} + +/// Open device handles, shared by all workers. Failed opens aren't remembered. +struct Table(RwLock>>); + +impl Table { + fn new() -> Self { + Table(RwLock::new(HashMap::new())) + } + + fn get(&self, path: &str, open: impl FnOnce() -> io::Result) -> io::Result> { + if let Some(entry) = self.0.read().expect("table lock").get(path) { + return Ok(entry.clone()); + } + let opened = Arc::new(open()?); + Ok(self + .0 + .write() + .expect("table lock") + .entry(path.to_string()) + .or_insert(opened) + .clone()) + } +} + +pub struct ChunkIo { + readers: Table, + writers: Table, + pub stats: IoStats, +} + +impl Default for ChunkIo { + fn default() -> Self { + Self::new() + } +} + +impl ChunkIo { + pub fn new() -> Self { + ChunkIo { + readers: Table::new(), + writers: Table::new(), + stats: IoStats::default(), + } + } + + /// Reads one whole chunk into `target` and verifies its CRC32. + pub fn read_chunk(&self, chunk: &Chunk, target: &mut [u8], bounce: &mut BounceBuffer) -> Result<(), ReadError> { + if target.len() as u64 != chunk.length { + return Err(io::Error::other("chunk length does not match its buffer").into()); + } + if chunk.is_shm() { + File::open(&chunk.device)?.read_exact_at(target, chunk.offset)?; + self.stats.buffered_read_bytes.fetch_add(target.len() as u64, Relaxed); + } else { + let fds = self.readers.get(&chunk.device, || open_for_read(&chunk.device))?; + let mut filled = 0; + if let Some(direct) = &fds.direct { + filled = self.read_direct(direct, fds.block_size, chunk.offset, target, bounce); + } + if filled < target.len() { + fds.buffered + .read_exact_at(&mut target[filled..], chunk.offset + filled as u64)?; + self.stats + .buffered_read_bytes + .fetch_add((target.len() - filled) as u64, Relaxed); + } + } + verify(chunk, target) + } + + /// Returns how many leading bytes of `target` were filled. Any failure leaves the rest for + /// the page cache path, which reports a real error if the data is unreadable. + fn read_direct( + &self, + file: &File, + block_size: usize, + offset: u64, + target: &mut [u8], + bounce: &mut BounceBuffer, + ) -> usize { + if block_size > BOUNCE_ALIGN || !offset.is_multiple_of(block_size as u64) { + return 0; + } + let length = target.len(); + let whole = length - length % block_size; + let mut done = 0; + + if (target.as_ptr() as usize).is_multiple_of(block_size) { + while done < whole { + match file.read_at(&mut target[done..whole], offset + done as u64) { + Ok(count) if count > 0 => { + done += count - count % block_size; + if count % block_size != 0 { + break; + } + } + Err(e) if e.kind() == io::ErrorKind::Interrupted => {} + _ => break, + } + } + self.stats.direct_read_bytes.fetch_add(done as u64, Relaxed); + if done < whole { + return done; + } + } else if whole > 0 { + let Ok(aligned) = bounce.slice(whole) else { return 0 }; + match read_aligned(file, aligned, offset, block_size) { + count if count == whole => target[..whole].copy_from_slice(aligned), + count => { + target[..count].copy_from_slice(&aligned[..count]); + self.stats.bounced_read_bytes.fetch_add(count as u64, Relaxed); + return count; + } + } + done = whole; + self.stats.bounced_read_bytes.fetch_add(whole as u64, Relaxed); + } + + // A partial last block. Allocations are rounded up to whole blocks, so reading all of it stays in bounds. + if whole < length { + let Ok(aligned) = bounce.slice(block_size) else { + return done; + }; + if read_aligned(file, aligned, offset + whole as u64, block_size) == block_size { + target[whole..].copy_from_slice(&aligned[..length - whole]); + done = length; + self.stats + .bounced_read_bytes + .fetch_add((length - whole) as u64, Relaxed); + } + } + done + } + + /// Writes one whole chunk. + pub fn write_chunk(&self, chunk: &Chunk, source: &[u8], bounce: &mut BounceBuffer) -> io::Result<()> { + if source.len() as u64 != chunk.length { + return Err(io::Error::other("chunk length does not match its buffer")); + } + if chunk.is_ram() { + return write_ram_chunk(&chunk.device, source); + } + let fds = self.writers.get(&chunk.device, || open_for_write(&chunk.device))?; + let mut written = 0; + if let Some(direct) = &fds.direct { + written = self.write_direct(direct, fds.block_size, chunk.offset, source, bounce)?; + } + if written < source.len() { + // Retries short writes, for example when the disk is nearly full + fds.buffered + .write_all_at(&source[written..], chunk.offset + written as u64)?; + self.stats + .buffered_write_bytes + .fetch_add((source.len() - written) as u64, Relaxed); + } + Ok(()) + } + + /// Writes as many whole blocks as O_DIRECT accepts and returns the bytes written. EINVAL means + /// O_DIRECT refused the request, so the caller finishes through the page cache. Other errors, + /// such as a failing drive, would fail there too and are reported. + fn write_direct( + &self, + file: &File, + block_size: usize, + offset: u64, + source: &[u8], + bounce: &mut BounceBuffer, + ) -> io::Result { + let whole = source.len() - source.len() % block_size; + if whole == 0 || block_size > BOUNCE_ALIGN || !offset.is_multiple_of(block_size as u64) { + return Ok(0); + } + let aligned_source = (source.as_ptr() as usize).is_multiple_of(block_size); + let data: &[u8] = if aligned_source { + &source[..whole] + } else { + let copy = bounce.slice(whole)?; + copy.copy_from_slice(&source[..whole]); + copy + }; + let mut written = 0; + while written < whole { + match file.write_at(&data[written..], offset + written as u64) { + Ok(count) => { + written += count; + if count == 0 || count % block_size != 0 { + break; + } + } + Err(e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) if e.raw_os_error() == Some(libc::EINVAL) => break, + Err(e) => return Err(e), + } + } + let counter = if aligned_source { + &self.stats.direct_write_bytes + } else { + &self.stats.bounced_write_bytes + }; + counter.fetch_add(written as u64, Relaxed); + Ok(written) + } + + /// Pushes page-cache writes to disk. Runs at shutdown only: commits are what make data durable. + pub fn sync(&self) { + for fds in self.writers.0.read().expect("table lock").values() { + let _ = fds.buffered.sync_all(); + } + } +} + +fn read_aligned(file: &File, buffer: &mut [u8], offset: u64, block_size: usize) -> usize { + let mut done = 0; + while done < buffer.len() { + match file.read_at(&mut buffer[done..], offset + done as u64) { + Ok(count) if count > 0 => { + done += count; + if count % block_size != 0 { + break; + } + } + Err(e) if e.kind() == io::ErrorKind::Interrupted => {} + _ => break, + } + } + done - done % block_size +} + +fn verify(chunk: &Chunk, data: &[u8]) -> Result<(), ReadError> { + let Some(expected) = chunk.checksum else { + return Err(io::Error::other("chunk has no checksum").into()); + }; + let actual = crc32fast::hash(data); + if actual != expected { + return Err(ReadError::Checksum(ChecksumMismatch { expected, actual })); + } + Ok(()) +} + +fn write_ram_chunk(path: &str, data: &[u8]) -> io::Result<()> { + // The daemon creates the directory. If it's missing, this process doesn't share /dev/shm with + // the daemon, and a private copy would silently disappear. + let parent = Path::new(path).parent().unwrap_or(Path::new("/")); + if !parent.is_dir() { + return Err(io::Error::new( + io::ErrorKind::NotFound, + format!( + "RAM chunk directory for {path} does not exist in this process; it must share /dev/shm with the daemon" + ), + )); + } + File::create(path)?.write_all(data) +} + +fn open_for_read(path: &str) -> io::Result { + Ok(ReadFds { + buffered: File::open(path)?, + direct: open_direct(path, false), + block_size: logical_block_size(path), + }) +} + +fn open_for_write(path: &str) -> io::Result { + let buffered = OpenOptions::new().read(true).write(true).open(path)?; + let is_block = buffered.metadata()?.file_type().is_block_device(); + let direct = if is_block { open_direct(path, true) } else { None }; + Ok(WriteFds { + buffered, + direct, + block_size: logical_block_size(path), + }) +} + +#[cfg(target_os = "linux")] +fn open_direct(path: &str, write: bool) -> Option { + OpenOptions::new() + .read(true) + .write(write) + .custom_flags(libc::O_DIRECT) + .open(path) + .ok() +} + +#[cfg(not(target_os = "linux"))] +fn open_direct(_path: &str, _write: bool) -> Option { + None +} + +/// The O_DIRECT alignment for a device, from sysfs, or 4096 when it isn't known. +pub fn logical_block_size(path: &str) -> usize { + let Ok(real) = std::fs::canonicalize(path) else { + return DEFAULT_BLOCK_SIZE; + }; + let Some(name) = real.file_name().and_then(|n| n.to_str()) else { + return DEFAULT_BLOCK_SIZE; + }; + let own = format!("/sys/class/block/{name}/queue/logical_block_size"); + // Partitions inherit the queue limits of their parent disk + let parent = std::fs::canonicalize(format!("/sys/class/block/{name}")) + .ok() + .and_then(|p| p.parent().map(|parent| parent.join("queue/logical_block_size"))); + for candidate in [Some(PathBuf::from(own)), parent].into_iter().flatten() { + if let Ok(text) = std::fs::read_to_string(&candidate) { + if let Ok(value) = text.trim().parse::() { + if value > 0 && value.is_power_of_two() { + return value.max(512); + } + } + } + } + DEFAULT_BLOCK_SIZE +} + +#[cfg(test)] +mod tests { + use super::*; + + fn temp_file(name: &str, size: usize) -> String { + let path = std::env::temp_dir().join(format!("hc-io-{}-{name}", std::process::id())); + std::fs::write(&path, vec![0u8; size]).unwrap(); + path.to_str().unwrap().to_string() + } + + fn pattern(length: usize, seed: u8) -> Vec { + (0..length) + .map(|i| (i as u8).wrapping_mul(31).wrapping_add(seed)) + .collect() + } + + fn chunk(device: &str, offset: u64, data: &[u8]) -> Chunk { + Chunk { + tier: "nvme".into(), + device: device.into(), + offset, + length: data.len() as u64, + checksum: Some(crc32fast::hash(data)), + } + } + + #[test] + fn crc_matches_zlib() { + // zlib.crc32(b"123456789") == 0xCBF43926, the value the daemon and Python client expect + assert_eq!(crc32fast::hash(b"123456789"), 0xCBF4_3926); + } + + #[test] + fn round_trips_at_any_length_and_alignment() { + let path = temp_file("roundtrip", 1 << 20); + let io = ChunkIo::new(); + let mut bounce = BounceBuffer::new(); + for (length, target_shift) in [(4096, 0), (8192, 1), (4097, 0), (123, 0), (65536 + 5, 3)] { + let data = pattern(length, length as u8); + let c = chunk(&path, 4096, &data); + io.write_chunk(&c, &data, &mut bounce).unwrap(); + let mut storage = vec![0u8; length + 8192]; + let start = (4096 - storage.as_ptr() as usize % 4096) % 4096 + target_shift; + let target = &mut storage[start..start + length]; + io.read_chunk(&c, target, &mut bounce).unwrap(); + assert_eq!(target, &data[..], "length {length}"); + } + std::fs::remove_file(path).unwrap(); + } + + #[test] + fn damaged_data_is_a_checksum_error() { + let path = temp_file("damaged", 1 << 16); + let io = ChunkIo::new(); + let mut bounce = BounceBuffer::new(); + let data = pattern(8192, 7); + let c = chunk(&path, 0, &data); + io.write_chunk(&c, &data, &mut bounce).unwrap(); + OpenOptions::new() + .write(true) + .open(&path) + .unwrap() + .write_all_at(&[0xAA], 100) + .unwrap(); + let mut target = vec![0u8; 8192]; + assert!(matches!( + io.read_chunk(&c, &mut target, &mut bounce), + Err(ReadError::Checksum(_)) + )); + std::fs::remove_file(path).unwrap(); + } + + #[test] + fn a_chunk_without_a_checksum_never_verifies() { + let path = temp_file("nosum", 8192); + let io = ChunkIo::new(); + let mut c = chunk(&path, 0, &[0u8; 4096]); + c.checksum = None; + let mut target = vec![0u8; 4096]; + assert!(io.read_chunk(&c, &mut target, &mut BounceBuffer::new()).is_err()); + std::fs::remove_file(path).unwrap(); + } + + #[test] + fn reading_past_the_end_is_an_error() { + let path = temp_file("short", 4096); + let io = ChunkIo::new(); + let data = pattern(8192, 1); + let c = chunk(&path, 0, &data); + let mut target = vec![0u8; 8192]; + assert!(matches!( + io.read_chunk(&c, &mut target, &mut BounceBuffer::new()), + Err(ReadError::Io(_)) + )); + std::fs::remove_file(path).unwrap(); + } + + #[test] + fn wrong_buffer_length_is_refused() { + let io = ChunkIo::new(); + let c = chunk("/nonexistent", 0, &[0u8; 4096]); + assert!(io.write_chunk(&c, &[0u8; 100], &mut BounceBuffer::new()).is_err()); + let mut target = [0u8; 100]; + assert!(io.read_chunk(&c, &mut target, &mut BounceBuffer::new()).is_err()); + } + + #[test] + fn ram_chunk_needs_the_shared_directory() { + let io = ChunkIo::new(); + let mut c = chunk("/definitely/not/shared/x.shm", 0, &[1u8; 16]); + c.tier = "ram".into(); + let error = io.write_chunk(&c, &[1u8; 16], &mut BounceBuffer::new()).unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::NotFound); + assert!(!Path::new("/definitely").exists()); + } + + #[test] + fn ram_chunk_round_trips() { + let path = temp_file("ram.shm", 0); + let io = ChunkIo::new(); + let data = pattern(5000, 9); + let mut c = chunk(&path, 0, &data); + c.tier = "ram".into(); + let mut bounce = BounceBuffer::new(); + io.write_chunk(&c, &data, &mut bounce).unwrap(); + let mut target = vec![0u8; 5000]; + io.read_chunk(&c, &mut target, &mut bounce).unwrap(); + assert_eq!(target, data); + std::fs::remove_file(path).unwrap(); + } +} diff --git a/lmcache-connector/src/key.rs b/lmcache-connector/src/key.rs new file mode 100644 index 0000000..575c5ab --- /dev/null +++ b/lmcache-connector/src/key.rs @@ -0,0 +1,118 @@ +//! Turns LMCache's native key strings into HyperCache URIs. +//! +//! The URI format must not change, or stored blocks can't be found. Every free-text +//! field is percent-encoded so none can add a path level, and salted and unsalted keys have +//! different shapes, so no salt can collide with "no salt". + +/// Percent-encodes like Python's `urllib.parse.quote(value, safe="")`. +pub fn quote(value: &str) -> String { + let mut out = String::with_capacity(value.len()); + for byte in value.bytes() { + match byte { + b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'_' | b'.' | b'-' | b'~' => out.push(byte as char), + _ => { + out.push('%'); + out.push(char::from_digit((byte >> 4) as u32, 16).unwrap().to_ascii_uppercase()); + out.push(char::from_digit((byte & 15) as u32, 16).unwrap().to_ascii_uppercase()); + } + } + } + out +} + +/// Maps `@@@[@]` to a URI. `quoted_namespace` must +/// already be quoted. Anything that doesn't parse is an error, which callers treat as a miss. +pub fn key_to_uri(quoted_namespace: &str, key: &str) -> Result { + let parts: Vec<&str> = key.split('@').collect(); + if parts.len() != 4 && parts.len() != 5 { + return Err(format!("malformed key: {key}")); + } + let (model, rank, group, hash) = (parts[0], parts[1], parts[2], parts[3]); + let rank = normalize_hex(rank).ok_or_else(|| format!("bad rank in key: {key}"))?; + let group = normalize_hex(group).ok_or_else(|| format!("bad group in key: {key}"))?; + if hash.is_empty() || !hash.bytes().all(|b| b.is_ascii_hexdigit()) { + return Err(format!("bad hash in key: {key}")); + } + let salt = match parts.get(4) { + None => "_".to_string(), + Some(&"") => return Err(format!("empty salt in key: {key}")), + Some(salt) => format!("s-{}", quote(salt)), + }; + Ok(format!( + "hypercache://kv_cache/{quoted_namespace}/{}/{rank}/{group}/{salt}/{hash}.kv", + quote(model) + )) +} + +/// Drops zero padding: URIs use `{:x}`, while LMCache pads the rank to 8 digits. +fn normalize_hex(value: &str) -> Option { + let parsed = i128::from_str_radix(value, 16).ok()?; + Some(if parsed < 0 { + format!("-{:x}", -parsed) + } else { + format!("{parsed:x}") + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn matches_python_quote() { + // Expected values come from Python's urllib.parse.quote(value, safe="") + assert_eq!(quote("Qwen/test-model"), "Qwen%2Ftest-model"); + assert_eq!(quote("a b+c~d_e.f"), "a%20b%2Bc~d_e.f"); + assert_eq!(quote("modèle"), "mod%C3%A8le"); + } + + #[test] + fn unsalted_key_uri_format() { + let uri = key_to_uri("ns", "Qwen/m@00000000@0@abc123").unwrap(); + assert_eq!(uri, "hypercache://kv_cache/ns/Qwen%2Fm/0/0/_/abc123.kv"); + } + + #[test] + fn rank_and_group_lose_padding() { + let uri = key_to_uri("ns", "m@0000001f@a@ff").unwrap(); + assert_eq!(uri, "hypercache://kv_cache/ns/m/1f/a/_/ff.kv"); + } + + #[test] + fn negative_group_uri_format() { + // Python formats -1 as "-1" with {:x}, and the rank's {:08x} as "-0000001" + assert_eq!( + key_to_uri("ns", "m@-0000001@-1@ff").unwrap(), + "hypercache://kv_cache/ns/m/-1/-1/_/ff.kv" + ); + } + + #[test] + fn salt_cannot_collide_with_no_salt() { + let salted = key_to_uri("ns", "m@0@0@ff@_").unwrap(); + assert_eq!(salted, "hypercache://kv_cache/ns/m/0/0/s-_/ff.kv"); + assert_ne!(salted, key_to_uri("ns", "m@0@0@ff").unwrap()); + } + + #[test] + fn fields_cannot_add_path_levels() { + let uri = key_to_uri("ns", "../../x@0@0@ff@a/b").unwrap(); + assert_eq!(uri, "hypercache://kv_cache/ns/..%2F..%2Fx/0/0/s-a%2Fb/ff.kv"); + } + + #[test] + fn malformed_keys_are_errors() { + for key in [ + "", + "m@0@0", + "m@0@0@ff@s@extra", + "m@zz@0@ff", + "m@0@zz@ff", + "m@0@0@not-hex", + "m@0@0@", + "m@0@0@ff@", + ] { + assert!(key_to_uri("ns", key).is_err(), "{key} should be rejected"); + } + } +} diff --git a/lmcache-connector/src/lib.rs b/lmcache-connector/src/lib.rs new file mode 100644 index 0000000..873f112 --- /dev/null +++ b/lmcache-connector/src/lib.rs @@ -0,0 +1,13 @@ +//! LMCache native L2 connector backed by the HyperCache daemon. +//! +//! LMCache's `native_plugin` type loads a class that exposes `event_fd`, `submit_batch_*`, +//! `drain_completions` and `close`. This crate provides that class in Rust, so everything below +//! LMCache's own wrapper runs without Python or the interpreter lock. + +pub mod connector; +pub mod daemon; +pub mod io; +pub mod key; + +#[cfg(feature = "python")] +mod python; diff --git a/lmcache-connector/src/python.rs b/lmcache-connector/src/python.rs new file mode 100644 index 0000000..bb2c327 --- /dev/null +++ b/lmcache-connector/src/python.rs @@ -0,0 +1,190 @@ +//! The Python face of the connector. Keeps to what crosses the boundary: arguments, buffers and +//! completions. Workers never touch the interpreter, and buffers are released in +//! `drain_completions`, which runs with the interpreter lock held. + +use crate::connector::{Config, Connector, RawBuffer}; +use pyo3::exceptions::{PyRuntimeError, PyValueError}; +use pyo3::prelude::*; +use pyo3::types::{PyDict, PyList}; +use pyo3::{ffi, IntoPyObjectExt}; +use std::env; +use std::mem::MaybeUninit; +use std::path::{Path, PathBuf}; +use std::sync::atomic::Ordering::Relaxed; +use std::time::Duration; + +/// A Python buffer held open until its batch completes. +struct HeldBuffer(Box); + +// A Py_buffer is plain data that keeps its exporter alive. Its only unsafe use is the release in +// `drop`, which takes the interpreter lock. +unsafe impl Send for HeldBuffer {} + +impl HeldBuffer { + fn acquire(object: &Bound<'_, PyAny>, writable: bool) -> PyResult { + let mut raw = Box::new(MaybeUninit::::zeroed()); + // PyBUF_SIMPLE asks for one contiguous run of bytes, and fails for anything else + let flags = if writable { + ffi::PyBUF_WRITABLE + } else { + ffi::PyBUF_SIMPLE + }; + if unsafe { ffi::PyObject_GetBuffer(object.as_ptr(), raw.as_mut_ptr(), flags) } != 0 { + return Err(PyErr::fetch(object.py())); + } + // PyObject_GetBuffer initialized it + let raw = unsafe { Box::from_raw(Box::into_raw(raw).cast::()) }; + Ok(HeldBuffer(raw)) + } + + fn raw(&self) -> RawBuffer { + RawBuffer { + ptr: self.0.buf.cast(), + len: self.0.len as usize, + } + } +} + +impl Drop for HeldBuffer { + fn drop(&mut self) { + Python::with_gil(|_| unsafe { ffi::PyBuffer_Release(&mut *self.0) }); + } +} + +fn acquire_all(memviews: &Bound<'_, PyAny>, writable: bool) -> PyResult<(Vec, Vec)> { + let mut held = Vec::new(); + for memview in memviews.try_iter()? { + held.push(HeldBuffer::acquire(&memview?, writable)?); + } + let raws = held.iter().map(HeldBuffer::raw).collect(); + Ok((held, raws)) +} + +fn default_socket_path() -> PathBuf { + // Same order as the Python client's get_default_socket_path + if let Some(path) = env::var("HYPERCACHE_SOCKET_PATH") + .ok() + .map(|p| p.trim().to_string()) + .filter(|p| !p.is_empty()) + { + return PathBuf::from(path); + } + const PRIMARY: &str = "/run/hypercache/hypercache.sock"; + const FALLBACK: &str = "/tmp/hypercache/hypercache.sock"; + const LEGACY: &str = "/tmp/hypercache.sock"; + for path in [PRIMARY, FALLBACK, LEGACY] { + if Path::new(path).exists() { + return PathBuf::from(path); + } + } + PathBuf::from(if Path::new("/run").exists() { PRIMARY } else { FALLBACK }) +} + +fn runtime_error(error: std::io::Error) -> PyErr { + PyRuntimeError::new_err(error.to_string()) +} + +/// Stores LMCache objects in HyperCache. Load it through LMCache's `native_plugin` adapter type. +#[pyclass(module = "hypercache_lmcache_native")] +struct HyperCacheNativeConnector { + inner: Connector, +} + +#[pymethods] +impl HyperCacheNativeConnector { + #[new] + #[pyo3(signature = (namespace, socket_path=None, tier="nvme", num_workers=32, timeout_s=30.0))] + fn new( + namespace: &str, + socket_path: Option<&str>, + tier: &str, + num_workers: usize, + timeout_s: f64, + ) -> PyResult { + if !(timeout_s.is_finite() && timeout_s > 0.0) { + return Err(PyValueError::new_err("timeout_s must be above zero")); + } + let config = Config { + namespace: namespace.to_string(), + socket_path: socket_path.map(PathBuf::from).unwrap_or_else(default_socket_path), + tier: tier.to_lowercase(), + num_workers, + timeout: Duration::from_secs_f64(timeout_s), + }; + config.validate().map_err(PyValueError::new_err)?; + Ok(HyperCacheNativeConnector { + inner: Connector::new(config).map_err(runtime_error)?, + }) + } + + fn event_fd(&self) -> i32 { + self.inner.event_fd() + } + + fn submit_batch_set(&self, keys: Vec, memviews: &Bound<'_, PyAny>) -> PyResult { + let (held, raws) = acquire_all(memviews, false)?; + // The held buffers travel with the batch and come back through drain_completions + unsafe { self.inner.submit_set(keys, raws, Box::new(held)) }.map_err(runtime_error) + } + + fn submit_batch_get(&self, keys: Vec, memviews: &Bound<'_, PyAny>) -> PyResult { + let (held, raws) = acquire_all(memviews, true)?; + unsafe { self.inner.submit_get(keys, raws, Box::new(held)) }.map_err(runtime_error) + } + + fn submit_batch_exists(&self, keys: Vec) -> PyResult { + self.inner.submit_exists(keys).map_err(runtime_error) + } + + fn submit_batch_delete(&self, keys: Vec) -> PyResult { + self.inner.submit_delete(keys).map_err(runtime_error) + } + + /// Returns a list of `(future_id, ok, error, per-key results)` tuples. + fn drain_completions<'py>(&self, py: Python<'py>) -> PyResult> { + let result = PyList::empty(py); + for completion in py.allow_threads(|| self.inner.drain_completions()) { + let results = PyList::new(py, &completion.results)?; + result.append((completion.future_id, completion.ok, &completion.error, results))?; + // Dropping the completion here releases its buffers, with the interpreter lock held + } + Ok(result) + } + + fn close(&self, py: Python<'_>) { + py.allow_threads(|| self.inner.close()); + } + + /// The HyperCache URI for one of LMCache's key strings. + fn uri(&self, key: &str) -> PyResult { + self.inner.uri(key).map_err(PyValueError::new_err) + } + + /// Failure and I/O path counters. LMCache's wrapper doesn't surface these in report_status. + fn stats<'py>(&self, py: Python<'py>) -> PyResult> { + let counters = self.inner.counters(); + let io = self.inner.io_stats(); + let stats = PyDict::new(py); + for (name, counter) in [ + ("checksum_failures", &counters.checksum_failures), + ("load_failures", &counters.load_failures), + ("store_failures", &counters.store_failures), + ("direct_read_bytes", &io.direct_read_bytes), + ("direct_write_bytes", &io.direct_write_bytes), + ("bounced_read_bytes", &io.bounced_read_bytes), + ("bounced_write_bytes", &io.bounced_write_bytes), + ("buffered_read_bytes", &io.buffered_read_bytes), + ("buffered_write_bytes", &io.buffered_write_bytes), + ] { + stats.set_item(name, counter.load(Relaxed).into_py_any(py)?)?; + } + Ok(stats) + } +} + +#[pymodule] +fn hypercache_lmcache_native(module: &Bound<'_, PyModule>) -> PyResult<()> { + module.add_class::()?; + module.add("__version__", env!("CARGO_PKG_VERSION"))?; + Ok(()) +} diff --git a/scripts/e2e/lmcache_l2_e2e.py b/scripts/e2e/lmcache_l2_e2e.py index 0438fd3..7fb7a4f 100644 --- a/scripts/e2e/lmcache_l2_e2e.py +++ b/scripts/e2e/lmcache_l2_e2e.py @@ -1,8 +1,9 @@ #!/usr/bin/env python3 """ -End-to-end check of the LMCache L2 adapter: real LMCache, real daemon, real device. +End-to-end check of the LMCache L2 connector in lmcache-connector/: real LMCache, real daemon, +real device. -Loads the adapter through LMCache's plugin loader, then checks round trips, restart behaviour, +Loads the connector through LMCache's plugin loader, then checks round trips, restart behaviour, misses and corruption handling. Needs a running daemon that can write to its device, and read and write access to that device, because the corruption test damages one stored chunk. @@ -23,26 +24,43 @@ from lmcache.v1.distributed.api import ObjectKey from lmcache.v1.distributed.l2_adapters import create_l2_adapter from lmcache.v1.distributed.l2_adapters.base import L2AdapterInterface -from lmcache.v1.distributed.l2_adapters.plugin_l2_adapter import PluginL2AdapterConfig +from lmcache.v1.distributed.l2_adapters.native_connector_l2_adapter import _object_key_to_string +from lmcache.v1.distributed.l2_adapters.native_plugin_l2_adapter import NativePluginL2AdapterConfig from hypercache.client import HyperCacheClient from hypercache.datapath import DirectBlockReader, DirectBlockWriter class Obj: - """A buffer with the attribute the adapter and LMCache's file adapter use.""" + """A buffer with the attribute LMCache's wrapper and file adapter use.""" def __init__(self, data): self.byte_array = memoryview(bytearray(data)) + def get_size(self): + return len(self.byte_array) + + +class AlignedObj: + """A page-aligned buffer, like LMCache's L1 allocator gives with 4 KiB alignment.""" + + def __init__(self, data): + self._map = mmap.mmap(-1, max(len(data), 1)) + self.byte_array = memoryview(self._map)[: len(data)] + self.byte_array[:] = data + + def get_size(self): + return len(self.byte_array) + def make_adapter(socket_path, namespace): - config = PluginL2AdapterConfig.from_dict( + config = NativePluginL2AdapterConfig.from_dict( { - "type": "plugin", - "module_path": "hypercache.integrations.lmcache_l2", - "class_name": "HyperCacheL2Adapter", + "type": "native_plugin", + "module_path": "hypercache_lmcache_native", + "class_name": "HyperCacheNativeConnector", "adapter_params": {"namespace": namespace, "socket_path": socket_path, "tier": "nvme"}, + "max_capacity_gb": 0, } ) adapter = create_l2_adapter(config) @@ -50,6 +68,19 @@ def make_adapter(socket_path, namespace): return adapter +def uri_of(adapter, stored_key): + return adapter._client.uri(_object_key_to_string(stored_key)) + + +def checksum_failures(adapter): + return adapter._client.stats()["checksum_failures"] + + +def used_o_direct(adapter): + stats = adapter._client.stats() + return stats["direct_write_bytes"] + stats["bounced_write_bytes"] > 0 + + def key(n, salt=""): return ObjectKey(hashlib.sha256(str(n).encode()).digest(), "Qwen/test-model", 0, 0, salt) @@ -92,7 +123,7 @@ def load(adapter, keys, objects): def client_device(socket_path, adapter, stored_key): client = HyperCacheClient(socket_path=socket_path) try: - return client.locate(adapter._uri(stored_key), auto_ingest=False).chunk_layout[0].device + return client.locate(uri_of(adapter, stored_key), auto_ingest=False).chunk_layout[0].device finally: client.close() @@ -135,6 +166,89 @@ def read_both(): client.evict(uri) +def io_checks(socket_path, namespace, size, check): + """The connector's own I/O paths, and the URI format that existing blocks depend on.""" + results = [] + rust = make_adapter(socket_path, namespace) + stats = rust._client.stats + + # Page-aligned buffers go to and from the drive with no copy + aligned_keys = [key(i) for i in range(200, 204)] + before = stats() + sources = [AlignedObj(block(i, size)) for i in range(200, 204)] + wait_store(rust, rust.submit_store_task(aligned_keys, sources)) + targets = [AlignedObj(bytes(size)) for _ in aligned_keys] + loaded = load(rust, aligned_keys, targets) + results.append(check("aligned buffers round trip", loaded == [True] * 4 and all(bytes(t.byte_array) == block(200 + i, size) for i, t in enumerate(targets)))) + after = stats() + is_block = stat.S_ISBLK(os.stat(client_device(socket_path, rust, aligned_keys[0])).st_mode) + if is_block: + results.append(check("aligned writes use O_DIRECT with no copy", after["direct_write_bytes"] - before["direct_write_bytes"] == 4 * size and after["bounced_write_bytes"] == before["bounced_write_bytes"])) + results.append(check("aligned reads use O_DIRECT with no copy", after["direct_read_bytes"] - before["direct_read_bytes"] == 4 * size and after["bounced_read_bytes"] == before["bounced_read_bytes"])) + results.append(check("repeat store writes nothing to the drive", True if wait_store(rust, rust.submit_store_task(aligned_keys, sources)) == 0 and stats()["direct_write_bytes"] == after["direct_write_bytes"] else False)) + + # Sizes that aren't whole blocks, in aligned and unaligned buffers + for name, factory, offset in (("aligned", AlignedObj, 0), ("unaligned", Obj, 10)): + odd_key = key(210 + offset) + odd_size = size + 123 + offset + wait_store(rust, rust.submit_store_task([odd_key], [factory(block(300 + offset, odd_size))])) + target = factory(bytes(odd_size)) + good = load(rust, [odd_key], [target]) == [True] and bytes(target.byte_array) == block(300 + offset, odd_size) + results.append(check(f"partial last block round trips, {name} buffer", good)) + + # What the Rust path wrote must read the same through the page cache + client = HyperCacheClient(socket_path=socket_path) + location = client.locate(uri_of(rust, aligned_keys[0]), auto_ingest=False) + fd = os.open(location.chunk_layout[0].device, os.O_RDONLY) + first = location.chunk_layout[0] + results.append(check("direct writes read back through the page cache", os.pread(fd, first.length, first.offset) == block(200, size)[: first.length])) + os.close(fd) + + # Blocks are found by URI, so changing this format would orphan every stored block + hash_hex = aligned_keys[0].chunk_hash.hex() + prefix = f"hypercache://kv_cache/{namespace}/Qwen%2Ftest-model/0/0" + results.append(check("URI format is unchanged", uri_of(rust, aligned_keys[0]) == f"{prefix}/_/{hash_hex}.kv")) + salted = key(220, salt="tenant a+b") + results.append(check("salted URI format is unchanged", uri_of(rust, salted) == f"{prefix}/s-tenant%20a%2Bb/{salted.chunk_hash.hex()}.kv")) + + # LMCache's wrapper doesn't check its locks before a delete. Losing a locked block must be a + # miss, never wrong data. + victim = key(240) + wait_store(rust, rust.submit_store_task([victim], [Obj(block(240, size))])) + lookup(rust, [victim]) + rust.delete([victim]) + target = AlignedObj(b"\x5a" * size) + missed = load(rust, [victim], [target]) == [False] + results.append(check("block deleted while locked is a miss", missed and bytes(target.byte_array) == b"\x5a" * size)) + rust.submit_unlock([victim]) + + # Many tasks at once, with every byte checked + many = [key(i) for i in range(400, 440)] + tasks = [rust.submit_store_task(many[i : i + 4], [Obj(block(400 + i + j, size // 4)) for j in range(4)]) for i in range(0, 40, 4)] + remaining = set(tasks) + deadline = time.time() + 120 + while remaining and time.time() < deadline: + select.select([rust.get_store_event_fd()], [], [], 0.1) + remaining -= set(rust.pop_completed_store_tasks()) + targets = [AlignedObj(bytes(size // 4)) for _ in many] + tasks = [(i, rust.submit_load_task(many[i : i + 4], targets[i : i + 4])) for i in range(0, 40, 4)] + all_loaded = all(wait_bits(rust.query_load_result, rust.get_load_event_fd(), task, 4) == [True] * 4 for _, task in tasks) + results.append(check("concurrent tasks return the right bytes", not remaining and all_loaded and all(bytes(t.byte_array) == block(400 + i, size // 4) for i, t in enumerate(targets)))) + + rust.close() + results.append(check("close releases cleanly and refuses new work", refuses_after_close(rust))) + client.close() + return results + + +def refuses_after_close(adapter): + try: + adapter._client.submit_batch_exists(["m@0@0@ff"]) + except RuntimeError: + return True + return False + + def check(name, condition): print(f"{'PASS' if condition else 'FAIL'} {name}", flush=True) return bool(condition) @@ -155,7 +269,7 @@ def main(): stored = wait_store(adapter, adapter.submit_store_task(keys, [Obj(block(i, size)) for i in range(8)])) results.append(check("store reports every byte", stored == 8 * size)) if stat.S_ISBLK(os.stat(client_device(args.socket, adapter, keys[0])).st_mode): - results.append(check("raw device writes use O_DIRECT", any(fd is not None for fd in adapter._writer._direct_fds.values()))) + results.append(check("raw device writes use O_DIRECT", used_o_direct(adapter))) results.append(check("repeat store writes nothing", wait_store(adapter, adapter.submit_store_task(keys, [Obj(block(i, size)) for i in range(8)])) == 0)) results.append(check("lookup finds stored keys only", lookup(adapter, keys + [key(99)]) == [True] * 8 + [False])) @@ -170,7 +284,7 @@ def main(): other.close() client = HyperCacheClient(socket_path=args.socket) - location = client.locate(adapter._uri(keys[0]), auto_ingest=False) + location = client.locate(uri_of(adapter, keys[0]), auto_ingest=False) results.append(check("block is LOCAL_ONLY", location.sync_status == "LOCAL_ONLY")) results.append(check("every chunk has a checksum", all(c.checksum is not None for c in location.chunk_layout))) @@ -189,7 +303,7 @@ def main(): results.append(check("corrupt block is removed", lookup(adapter, keys[:1]) == [False])) results.append(check("other blocks still load", load(adapter, keys[1:2], [Obj(bytes(size))]) == [True])) adapter.submit_unlock(keys[1:2]) - results.append(check("status counts the checksum failure", adapter.report_status()["checksum_failures"] == 1)) + results.append(check("status counts the checksum failure", checksum_failures(adapter) == 1)) wrong = load(adapter, keys[1:2], [Obj(bytes(size - 4096))]) results.append(check("wrong buffer size is a miss", wrong == [False])) @@ -204,6 +318,8 @@ def main(): adapter.close() client.close() + results.extend(io_checks(args.socket, namespace + "-io", size, check)) + passed = sum(results) print(json.dumps({"passed": passed, "total": len(results)})) return 0 if passed == len(results) else 1 diff --git a/scripts/verify_release.sh b/scripts/verify_release.sh index 2a79818..980aa9d 100755 --- a/scripts/verify_release.sh +++ b/scripts/verify_release.sh @@ -74,6 +74,7 @@ else fi CARGO_MANIFEST="control-plane/Cargo.toml" +CONNECTOR_MANIFEST="lmcache-connector/Cargo.toml" RELEASE_DIR="$REPO_ROOT/control-plane/target/release" LOG_DIR="$(mktemp -d "${TMPDIR:-/tmp}/hc-verify-logs.XXXXXX")" @@ -208,7 +209,8 @@ except ImportError: except ImportError: print("tomllib unavailable (Python < 3.11); skipping") sys.exit(0) -for f in glob.glob("configs/*.toml") + ["control-plane/Cargo.toml", "client-py/pyproject.toml", "control-plane/rustfmt.toml"]: +for f in glob.glob("configs/*.toml") + ["control-plane/Cargo.toml", "client-py/pyproject.toml", "control-plane/rustfmt.toml", + "lmcache-connector/Cargo.toml", "lmcache-connector/pyproject.toml"]: with open(f, "rb") as fh: tomllib.load(fh) print(f"{f}: ok") @@ -233,6 +235,9 @@ stage_static() { step "no hardcoded version strings in Rust sources and tests" check_no_hardcoded_versions step "zero-emoji policy (AGENTS.md rule 1)" check_emoji_policy step "cargo fmt --check" cargo fmt --manifest-path "$CARGO_MANIFEST" -- --check + step "lmcache-connector: cargo fmt --check" cargo fmt --manifest-path "$CONNECTOR_MANIFEST" -- --check + step "lmcache-connector: cargo clippy -D warnings" \ + cargo clippy --locked --manifest-path "$CONNECTOR_MANIFEST" --all-targets -- -D warnings step "cargo clippy --all-targets -D warnings (Cargo.lock locked)" \ cargo clippy --locked --manifest-path "$CARGO_MANIFEST" --all-targets -- -D warnings step "python byte-compile (client + scripts)" check_python_compile @@ -271,6 +276,7 @@ check_missing_config_is_error() { stage_rust() { section "rust" step "cargo test (unit + integration, locked)" cargo test --locked --manifest-path "$CARGO_MANIFEST" + step "lmcache-connector: cargo test" cargo test --locked --manifest-path "$CONNECTOR_MANIFEST" step "cargo build --release" cargo build --locked --release --manifest-path "$CARGO_MANIFEST" step "release binaries: --version and every subcommand --help" check_binaries step "daemon refuses to start without a config file" check_missing_config_is_error From 9d59269c8c246a17559125b993102ca11746b0df Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 03:26:53 -0600 Subject: [PATCH 3/9] fix(connector): reconnect after a daemon restart Each worker keeps a connection to the daemon. After a restart that connection is dead, so the worker's next request failed with a broken pipe: one failed store or load per worker, with 32 failures at the default worker count. A request that fails while being written can't have reached the daemon, so it now reconnects and sends it again, once. A failure after that point is never resent, because the daemon may already have acted on the request, so a commit can't run twice. Repeated on 4 NVMe drives: no failed first stores after a daemon restart, in all 10 crash and restart tests. --- lmcache-connector/src/daemon.rs | 131 ++++++++++++++++++++++++++++++-- 1 file changed, 123 insertions(+), 8 deletions(-) diff --git a/lmcache-connector/src/daemon.rs b/lmcache-connector/src/daemon.rs index 05a1c20..9a2c771 100644 --- a/lmcache-connector/src/daemon.rs +++ b/lmcache-connector/src/daemon.rs @@ -68,6 +68,10 @@ impl Response { } } +fn connection_is_dead(error: &io::Error) -> bool { + matches!(error.kind(), io::ErrorKind::BrokenPipe | io::ErrorKind::ConnectionReset) +} + pub struct DaemonClient { socket_path: PathBuf, timeout: Duration, @@ -99,17 +103,22 @@ impl DaemonClient { } fn exchange(&mut self, body: &Value, timeout: Duration) -> io::Result { - if self.stream.is_none() { - self.stream = Some(BufReader::new(UnixStream::connect(&self.socket_path)?)); - } - let reader = self.stream.as_mut().expect("connected above"); - reader.get_ref().set_read_timeout(Some(timeout))?; - reader.get_ref().set_write_timeout(Some(timeout))?; - let mut message = serde_json::to_vec(body)?; message.push(b'\n'); - reader.get_mut().write_all(&message)?; + // A kept connection dies when the daemon restarts, and the next write is what finds out. + // The daemon can't have received that request, so resending it is safe. A failure after + // this point is never resent, because the daemon may already have acted on the request. + let reused = self.stream.is_some(); + match self.send(&message, timeout) { + Err(error) if reused && connection_is_dead(&error) => { + self.stream = None; + self.send(&message, timeout)?; + } + other => other?, + } + + let reader = self.stream.as_mut().expect("connected by send"); loop { self.line.clear(); if reader.read_line(&mut self.line)? == 0 { @@ -124,6 +133,18 @@ impl DaemonClient { } } + fn send(&mut self, message: &[u8], timeout: Duration) -> io::Result<()> { + if self.stream.is_none() { + self.stream = Some(BufReader::new(UnixStream::connect(&self.socket_path)?)); + } + let reader = self.stream.as_mut().expect("connected above"); + // macOS refuses these on a socket whose peer has gone, before anything is written + let dead = |error| io::Error::new(io::ErrorKind::BrokenPipe, error); + reader.get_ref().set_read_timeout(Some(timeout)).map_err(dead)?; + reader.get_ref().set_write_timeout(Some(timeout)).map_err(dead)?; + reader.get_mut().write_all(message) + } + pub fn locate(&mut self, uri: &str) -> io::Result { let body = json!({"action": "locate", "uri": uri, "auto_ingest": false, "pinned": false}); self.request(&body, self.timeout) @@ -167,3 +188,97 @@ impl DaemonClient { Ok(matches!(response.status.as_str(), "EVICTED" | "PONG" | "OK")) } } + +#[cfg(test)] +mod tests { + use super::*; + use std::os::unix::net::UnixListener; + use std::sync::atomic::{AtomicUsize, Ordering}; + + const TIMEOUT: Duration = Duration::from_secs(5); + + fn socket_path(name: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("hc-client-{}-{}", std::process::id(), name)); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + dir.join("d.sock") + } + + /// Answers one request on one connection, then closes it. + fn answer_one(listener: &UnixListener, requests: &AtomicUsize) { + // Gives up rather than blocking, so a failed assertion can't hang the test run + listener.set_nonblocking(true).unwrap(); + let deadline = std::time::Instant::now() + TIMEOUT; + let stream = loop { + match listener.accept() { + Ok((stream, _)) => break stream, + Err(_) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(5)), + Err(error) => panic!("no connection: {error}"), + } + }; + stream.set_nonblocking(false).unwrap(); + let mut reader = BufReader::new(stream); + let mut line = String::new(); + reader.read_line(&mut line).unwrap(); + requests.fetch_add(1, Ordering::SeqCst); + reader.get_mut().write_all(b"{\"status\":\"MISS\"}\n").unwrap(); + } + + #[test] + fn request_survives_a_daemon_restart_on_a_kept_connection() { + let socket = socket_path("restart"); + let listener = UnixListener::bind(&socket).unwrap(); + let requests = AtomicUsize::new(0); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + + std::thread::scope(|scope| { + scope.spawn(|| answer_one(&listener, &requests)); + assert_eq!(client.locate("hypercache://a").unwrap().status, "MISS"); + }); + // The old connection is closed now. The next request should reconnect and go through once. + std::thread::scope(|scope| { + scope.spawn(|| answer_one(&listener, &requests)); + assert_eq!(client.locate("hypercache://a").unwrap().status, "MISS"); + }); + assert_eq!(requests.load(Ordering::SeqCst), 2); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } + + #[test] + fn request_the_daemon_received_is_never_resent() { + let socket = socket_path("received"); + let listener = UnixListener::bind(&socket).unwrap(); + listener.set_nonblocking(true).unwrap(); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + + // A kept connection whose daemon reads the request, then dies before it replies + let (near, far) = UnixStream::pair().unwrap(); + client.stream = Some(BufReader::new(near)); + let daemon = std::thread::spawn(move || { + let mut line = String::new(); + BufReader::new(far).read_line(&mut line).unwrap(); + }); + + assert!(client.request(&json!({"action": "commit"}), TIMEOUT).is_err()); + daemon.join().unwrap(); + // A resend would have had to reconnect through this listener + assert_eq!(listener.accept().unwrap_err().kind(), io::ErrorKind::WouldBlock); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } + + #[test] + fn a_daemon_that_is_really_down_is_still_an_error() { + let socket = socket_path("down"); + let listener = UnixListener::bind(&socket).unwrap(); + let requests = AtomicUsize::new(0); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + std::thread::scope(|scope| { + scope.spawn(|| answer_one(&listener, &requests)); + client.locate("hypercache://a").unwrap(); + }); + drop(listener); + std::fs::remove_file(&socket).unwrap(); + assert!(client.locate("hypercache://a").is_err()); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } +} From 436640ed2e92b165183ae6e161ee45bb63d07a20 Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 03:27:24 -0600 Subject: [PATCH 4/9] docs: add LMCache connector guides and bare-metal NVMe results Adds install, configuration and limits to GETTING_STARTED.md, ARCHITECTURE.md, client-py/README.md and the connector's README, and the results from 4 Micron 7450 drives: striping, worker counts, raw_block comparison, mixed reads and writes, failure tests, upgrades and a 30-minute soak. --- ARCHITECTURE.md | 11 + CHANGELOG.md | 5 +- GETTING_STARTED.md | 32 + README.md | 2 +- .../rust-connector-epyc/baseline/memory.txt | 28 + .../rust-connector-epyc/baseline/r1_1.json | 277 +++ .../rust-connector-epyc/baseline/r1_2.json | 277 +++ .../rust-connector-epyc/baseline/r1_3.json | 277 +++ .../rust-connector-epyc/baseline/r2_1.json | 290 +++ .../rust-connector-epyc/baseline/r2_2.json | 290 +++ .../rust-connector-epyc/baseline/r2_3.json | 290 +++ .../rust-connector-epyc/baseline/r4_1.json | 316 +++ .../rust-connector-epyc/baseline/r4_2.json | 316 +++ .../rust-connector-epyc/baseline/r4_3.json | 316 +++ .../baseline/r_nvme1n1.json | 277 +++ .../baseline/r_nvme2n1.json | 277 +++ .../baseline/r_nvme3n1.json | 277 +++ .../baseline/r_nvme4n1.json | 277 +++ .../rust-connector-epyc/baseline/w1_1.json | 277 +++ .../rust-connector-epyc/baseline/w1_2.json | 277 +++ .../rust-connector-epyc/baseline/w1_3.json | 277 +++ .../rust-connector-epyc/baseline/w2_1.json | 290 +++ .../rust-connector-epyc/baseline/w2_2.json | 290 +++ .../rust-connector-epyc/baseline/w2_3.json | 290 +++ .../rust-connector-epyc/baseline/w4_1.json | 316 +++ .../rust-connector-epyc/baseline/w4_2.json | 316 +++ .../rust-connector-epyc/baseline/w4_3.json | 316 +++ .../baseline/w_nvme1n1.json | 277 +++ .../baseline/w_nvme2n1.json | 277 +++ .../baseline/w_nvme3n1.json | 277 +++ .../baseline/w_nvme4n1.json | 277 +++ .../rust-connector-epyc/diag/ru14-1.cpu | 1 + .../rust-connector-epyc/diag/ru14-1.json | 73 + .../rust-connector-epyc/diag/ru16-1.cpu | 1 + .../rust-connector-epyc/diag/ru16-1.json | 73 + .../rust-connector-epyc/failure/results.jsonl | 14 + .../failure_final/results.jsonl | 12 + .../fio_mixed/read_only_1.json | 1073 ++++++++ .../fio_mixed/read_only_2.json | 1073 ++++++++ .../fio_mixed/read_only_3.json | 1073 ++++++++ .../fio_mixed/write_1000_each_1.json | 2089 ++++++++++++++++ .../fio_mixed/write_1000_each_2.json | 2089 ++++++++++++++++ .../fio_mixed/write_1000_each_3.json | 2089 ++++++++++++++++ .../fio_mixed/write_full_1.json | 2085 ++++++++++++++++ .../fio_mixed/write_full_2.json | 2085 ++++++++++++++++ .../fio_mixed/write_full_3.json | 2085 ++++++++++++++++ .../fio_mixed/write_full_fsync_1.json | 2165 +++++++++++++++++ .../fio_mixed/write_full_fsync_2.json | 2165 +++++++++++++++++ .../fio_mixed/write_full_fsync_3.json | 2165 +++++++++++++++++ .../fixed/base_14mib_d2_w32-1.cpu | 1 + .../fixed/base_14mib_d2_w32-1.json | 73 + .../fixed/base_14mib_d2_w32-2.cpu | 1 + .../fixed/base_14mib_d2_w32-2.json | 73 + .../fixed/base_14mib_d2_w32-3.cpu | 1 + .../fixed/base_14mib_d2_w32-3.json | 73 + .../fixed/base_14mib_d4_w128-1.cpu | 1 + .../fixed/base_14mib_d4_w128-1.json | 73 + .../fixed/base_14mib_d4_w128-2.cpu | 1 + .../fixed/base_14mib_d4_w128-2.json | 73 + .../fixed/base_14mib_d4_w128-3.cpu | 1 + .../fixed/base_14mib_d4_w128-3.json | 73 + .../fixed/base_14mib_d4_w32-1.cpu | 1 + .../fixed/base_14mib_d4_w32-1.json | 73 + .../fixed/base_14mib_d4_w32-2.cpu | 1 + .../fixed/base_14mib_d4_w32-2.json | 73 + .../fixed/base_14mib_d4_w32-3.cpu | 1 + .../fixed/base_14mib_d4_w32-3.json | 73 + .../fixed/base_16mib_d4_w32-1.cpu | 1 + .../fixed/base_16mib_d4_w32-1.json | 73 + .../fixed/base_16mib_d4_w32-2.cpu | 1 + .../fixed/base_16mib_d4_w32-2.json | 73 + .../fixed/base_16mib_d4_w32-3.cpu | 1 + .../fixed/base_16mib_d4_w32-3.json | 73 + .../fixed/base_2mib_d4_w32-1.cpu | 1 + .../fixed/base_2mib_d4_w32-1.json | 73 + .../fixed/base_2mib_d4_w32-2.cpu | 1 + .../fixed/base_2mib_d4_w32-2.json | 73 + .../fixed/base_2mib_d4_w32-3.cpu | 1 + .../fixed/base_2mib_d4_w32-3.json | 73 + .../fixed/fix_14mib_d2_w32-1.cpu | 1 + .../fixed/fix_14mib_d2_w32-1.json | 73 + .../fixed/fix_14mib_d2_w32-2.cpu | 1 + .../fixed/fix_14mib_d2_w32-2.json | 73 + .../fixed/fix_14mib_d2_w32-3.cpu | 1 + .../fixed/fix_14mib_d2_w32-3.json | 73 + .../fixed/fix_14mib_d4_w128-1.cpu | 1 + .../fixed/fix_14mib_d4_w128-1.json | 73 + .../fixed/fix_14mib_d4_w128-2.cpu | 1 + .../fixed/fix_14mib_d4_w128-2.json | 73 + .../fixed/fix_14mib_d4_w128-3.cpu | 1 + .../fixed/fix_14mib_d4_w128-3.json | 73 + .../fixed/fix_14mib_d4_w32-1.cpu | 1 + .../fixed/fix_14mib_d4_w32-1.json | 73 + .../fixed/fix_14mib_d4_w32-2.cpu | 1 + .../fixed/fix_14mib_d4_w32-2.json | 73 + .../fixed/fix_14mib_d4_w32-3.cpu | 1 + .../fixed/fix_14mib_d4_w32-3.json | 73 + .../fixed/fix_14mib_d4_w64-1.cpu | 1 + .../fixed/fix_14mib_d4_w64-1.json | 73 + .../fixed/fix_14mib_d4_w64-2.cpu | 1 + .../fixed/fix_14mib_d4_w64-2.json | 73 + .../fixed/fix_14mib_d4_w64-3.cpu | 1 + .../fixed/fix_14mib_d4_w64-3.json | 73 + .../fixed/fix_16mib_d4_w32-1.cpu | 1 + .../fixed/fix_16mib_d4_w32-1.json | 73 + .../fixed/fix_16mib_d4_w32-2.cpu | 1 + .../fixed/fix_16mib_d4_w32-2.json | 73 + .../fixed/fix_16mib_d4_w32-3.cpu | 1 + .../fixed/fix_16mib_d4_w32-3.json | 73 + .../fixed/fix_2mib_d4_w32-1.cpu | 1 + .../fixed/fix_2mib_d4_w32-1.json | 73 + .../fixed/fix_2mib_d4_w32-2.cpu | 1 + .../fixed/fix_2mib_d4_w32-2.json | 73 + .../fixed/fix_2mib_d4_w32-3.cpu | 1 + .../fixed/fix_2mib_d4_w32-3.json | 73 + .../rust-connector-epyc/fixed_iostat_base.txt | 407 ++++ .../rust-connector-epyc/fixed_iostat_fix.txt | 358 +++ .../rust-connector-epyc/io14.txt | 148 ++ .../rust-connector-epyc/io16.txt | 155 ++ .../main_upgrade/results.jsonl | 14 + .../rust-connector-epyc/mixed/fill-1.json | 1 + .../rust-connector-epyc/mixed/fill-2.json | 1 + .../rust-connector-epyc/mixed/fill-3.json | 1 + .../mixed/load_alone-1.json | 1 + .../mixed/load_alone-2.json | 1 + .../mixed/load_alone-3.json | 1 + .../rust-connector-epyc/mixed/r_rate0-1.json | 1 + .../rust-connector-epyc/mixed/r_rate0-2.json | 1 + .../rust-connector-epyc/mixed/r_rate0-3.json | 1 + .../mixed/r_rate1000-1.json | 1 + .../mixed/r_rate1000-2.json | 1 + .../mixed/r_rate1000-3.json | 1 + .../mixed/r_rate4000-1.json | 1 + .../mixed/r_rate4000-2.json | 1 + .../mixed/r_rate4000-3.json | 1 + .../mixed/store_alone-1.json | 1 + .../mixed/store_alone-2.json | 1 + .../mixed/store_alone-3.json | 1 + .../rust-connector-epyc/mixed/w_rate0-1.json | 1 + .../rust-connector-epyc/mixed/w_rate0-2.json | 1 + .../rust-connector-epyc/mixed/w_rate0-3.json | 1 + .../mixed/w_rate1000-1.json | 1 + .../mixed/w_rate1000-2.json | 1 + .../mixed/w_rate1000-3.json | 1 + .../mixed/w_rate4000-1.json | 1 + .../mixed/w_rate4000-2.json | 1 + .../mixed/w_rate4000-3.json | 1 + .../one_if16/raw_posix_w32-1.cpu | 1 + .../one_if16/raw_posix_w32-1.json | 73 + .../one_if16/raw_posix_w32-2.cpu | 1 + .../one_if16/raw_posix_w32-2.json | 73 + .../one_if16/raw_posix_w32-3.cpu | 1 + .../one_if16/raw_posix_w32-3.json | 73 + .../one_if16/raw_posix_w8-1.cpu | 1 + .../one_if16/raw_posix_w8-1.json | 73 + .../one_if16/raw_posix_w8-2.cpu | 1 + .../one_if16/raw_posix_w8-2.json | 73 + .../one_if16/raw_posix_w8-3.cpu | 1 + .../one_if16/raw_posix_w8-3.json | 73 + .../one_if16/raw_uring_w32-1.cpu | 1 + .../one_if16/raw_uring_w32-1.json | 73 + .../one_if16/raw_uring_w32-2.cpu | 1 + .../one_if16/raw_uring_w32-2.json | 73 + .../one_if16/raw_uring_w32-3.cpu | 1 + .../one_if16/raw_uring_w32-3.json | 73 + .../one_if16/raw_uring_w8-1.cpu | 1 + .../one_if16/raw_uring_w8-1.json | 73 + .../one_if16/raw_uring_w8-2.cpu | 1 + .../one_if16/raw_uring_w8-2.json | 73 + .../one_if16/raw_uring_w8-3.cpu | 1 + .../one_if16/raw_uring_w8-3.json | 73 + .../one_if16/rust_w32-1.cpu | 1 + .../one_if16/rust_w32-1.json | 73 + .../one_if16/rust_w32-2.cpu | 1 + .../one_if16/rust_w32-2.json | 73 + .../one_if16/rust_w32-3.cpu | 1 + .../one_if16/rust_w32-3.json | 73 + .../one_if16/rust_w8-1.cpu | 1 + .../one_if16/rust_w8-1.json | 73 + .../one_if16/rust_w8-2.cpu | 1 + .../one_if16/rust_w8-2.json | 73 + .../one_if16/rust_w8-3.cpu | 1 + .../one_if16/rust_w8-3.json | 73 + .../one_if4/raw_uring_w8-1.cpu | 1 + .../one_if4/raw_uring_w8-1.json | 73 + .../one_if4/raw_uring_w8-2.cpu | 1 + .../one_if4/raw_uring_w8-2.json | 73 + .../one_if4/raw_uring_w8-3.cpu | 1 + .../one_if4/raw_uring_w8-3.json | 73 + .../rust-connector-epyc/one_if4/rust_w8-1.cpu | 1 + .../one_if4/rust_w8-1.json | 73 + .../rust-connector-epyc/one_if4/rust_w8-2.cpu | 1 + .../one_if4/rust_w8-2.json | 73 + .../rust-connector-epyc/one_if4/rust_w8-3.cpu | 1 + .../one_if4/rust_w8-3.json | 73 + .../rust-connector-epyc/pilot/rb_posix-1.cpu | 1 + .../rust-connector-epyc/pilot/rb_posix-1.json | 73 + .../rust-connector-epyc/pilot/rb_uring-1.cpu | 1 + .../rust-connector-epyc/pilot/rb_uring-1.json | 73 + .../rust-connector-epyc/pilot/ru_d1-1.cpu | 1 + .../rust-connector-epyc/pilot/ru_d1-1.json | 73 + .../rust-connector-epyc/pilot/ru_d4-1.cpu | 1 + .../rust-connector-epyc/pilot/ru_d4-1.json | 73 + .../rust-connector-epyc/pilot/ru_ram-1.cpu | 1 + .../rust-connector-epyc/pilot/ru_ram-1.json | 73 + .../raid0/raw_uring_d2_w32-1.cpu | 1 + .../raid0/raw_uring_d2_w32-1.json | 73 + .../raid0/raw_uring_d2_w32-2.cpu | 1 + .../raid0/raw_uring_d2_w32-2.json | 73 + .../raid0/raw_uring_d2_w32-3.cpu | 1 + .../raid0/raw_uring_d2_w32-3.json | 73 + .../raid0/raw_uring_d2_w64-1.cpu | 1 + .../raid0/raw_uring_d2_w64-1.json | 73 + .../raid0/raw_uring_d2_w64-2.cpu | 1 + .../raid0/raw_uring_d2_w64-2.json | 73 + .../raid0/raw_uring_d2_w64-3.cpu | 1 + .../raid0/raw_uring_d2_w64-3.json | 73 + .../raid0/raw_uring_d4_w32-1.cpu | 1 + .../raid0/raw_uring_d4_w32-1.json | 73 + .../raid0/raw_uring_d4_w32-2.cpu | 1 + .../raid0/raw_uring_d4_w32-2.json | 73 + .../raid0/raw_uring_d4_w32-3.cpu | 1 + .../raid0/raw_uring_d4_w32-3.json | 73 + .../raid0/raw_uring_d4_w64-1.cpu | 1 + .../raid0/raw_uring_d4_w64-1.json | 73 + .../raid0/raw_uring_d4_w64-2.cpu | 1 + .../raid0/raw_uring_d4_w64-2.json | 73 + .../raid0/raw_uring_d4_w64-3.cpu | 1 + .../raid0/raw_uring_d4_w64-3.json | 73 + .../scale_14mib/rust_d1_w32-1.cpu | 1 + .../scale_14mib/rust_d1_w32-1.json | 73 + .../scale_14mib/rust_d1_w32-2.cpu | 1 + .../scale_14mib/rust_d1_w32-2.json | 73 + .../scale_14mib/rust_d1_w32-3.cpu | 1 + .../scale_14mib/rust_d1_w32-3.json | 73 + .../scale_14mib/rust_d2_w32-1.cpu | 1 + .../scale_14mib/rust_d2_w32-1.json | 73 + .../scale_14mib/rust_d2_w32-2.cpu | 1 + .../scale_14mib/rust_d2_w32-2.json | 73 + .../scale_14mib/rust_d2_w32-3.cpu | 1 + .../scale_14mib/rust_d2_w32-3.json | 73 + .../scale_14mib/rust_d4_w32-1.cpu | 1 + .../scale_14mib/rust_d4_w32-1.json | 73 + .../scale_14mib/rust_d4_w32-2.cpu | 1 + .../scale_14mib/rust_d4_w32-2.json | 73 + .../scale_14mib/rust_d4_w32-3.cpu | 1 + .../scale_14mib/rust_d4_w32-3.json | 73 + .../scale_16mib/rust_d1_w32-1.cpu | 1 + .../scale_16mib/rust_d1_w32-1.json | 73 + .../scale_16mib/rust_d1_w32-2.cpu | 1 + .../scale_16mib/rust_d1_w32-2.json | 73 + .../scale_16mib/rust_d1_w32-3.cpu | 1 + .../scale_16mib/rust_d1_w32-3.json | 73 + .../scale_16mib/rust_d2_w32-1.cpu | 1 + .../scale_16mib/rust_d2_w32-1.json | 73 + .../scale_16mib/rust_d2_w32-2.cpu | 1 + .../scale_16mib/rust_d2_w32-2.json | 73 + .../scale_16mib/rust_d2_w32-3.cpu | 1 + .../scale_16mib/rust_d2_w32-3.json | 73 + .../scale_16mib/rust_d4_w32-1.cpu | 1 + .../scale_16mib/rust_d4_w32-1.json | 73 + .../scale_16mib/rust_d4_w32-2.cpu | 1 + .../scale_16mib/rust_d4_w32-2.json | 73 + .../scale_16mib/rust_d4_w32-3.cpu | 1 + .../scale_16mib/rust_d4_w32-3.json | 73 + .../rust-connector-epyc/soak/dmesg_after.txt | 1 + .../rust-connector-epyc/soak/dmesg_before.txt | 1 + .../rust-connector-epyc/soak/fill.json | 1 + .../rust-connector-epyc/soak/iostat.txt | 312 +++ .../rust-connector-epyc/soak/load.jsonl | 31 + .../rust-connector-epyc/soak/monitor.txt | 30 + .../rust-connector-epyc/soak/smart_after.txt | 24 + .../rust-connector-epyc/soak/smart_before.txt | 24 + .../rust-connector-epyc/soak/store.jsonl | 31 + .../sweep/d4/ru_w128_if16-1.cpu | 1 + .../sweep/d4/ru_w128_if16-1.json | 73 + .../sweep/d4/ru_w128_if64-1.cpu | 1 + .../sweep/d4/ru_w128_if64-1.json | 73 + .../sweep/d4/ru_w256_if16-1.cpu | 1 + .../sweep/d4/ru_w256_if16-1.json | 73 + .../sweep/d4/ru_w256_if64-1.cpu | 1 + .../sweep/d4/ru_w256_if64-1.json | 73 + .../sweep/d4/ru_w32_if16-1.cpu | 1 + .../sweep/d4/ru_w32_if16-1.json | 73 + .../sweep/d4/ru_w32_if64-1.cpu | 1 + .../sweep/d4/ru_w32_if64-1.json | 73 + .../sweep/d4/ru_w64_if16-1.cpu | 1 + .../sweep/d4/ru_w64_if16-1.json | 73 + .../sweep/d4/ru_w64_if64-1.cpu | 1 + .../sweep/d4/ru_w64_if64-1.json | 73 + .../sweep/ram/ru_w128_if16-1.cpu | 1 + .../sweep/ram/ru_w128_if16-1.json | 73 + .../sweep/ram/ru_w128_if64-1.cpu | 1 + .../sweep/ram/ru_w128_if64-1.json | 73 + .../sweep/ram/ru_w32_if16-1.cpu | 1 + .../sweep/ram/ru_w32_if16-1.json | 73 + .../sweep/ram/ru_w64_if16-1.cpu | 1 + .../sweep/ram/ru_w64_if16-1.json | 73 + .../workers/fix_14mib_d4_w16-1.cpu | 1 + .../workers/fix_14mib_d4_w16-1.json | 73 + .../workers/fix_14mib_d4_w16-2.cpu | 1 + .../workers/fix_14mib_d4_w16-2.json | 73 + .../workers/fix_14mib_d4_w16-3.cpu | 1 + .../workers/fix_14mib_d4_w16-3.json | 73 + .../workers/fix_14mib_d4_w32-1.cpu | 1 + .../workers/fix_14mib_d4_w32-1.json | 73 + .../workers/fix_14mib_d4_w32-2.cpu | 1 + .../workers/fix_14mib_d4_w32-2.json | 73 + .../workers/fix_14mib_d4_w32-3.cpu | 1 + .../workers/fix_14mib_d4_w32-3.json | 73 + .../workers/fix_14mib_d4_w8-1.cpu | 1 + .../workers/fix_14mib_d4_w8-1.json | 73 + .../workers/fix_14mib_d4_w8-2.cpu | 1 + .../workers/fix_14mib_d4_w8-2.json | 73 + .../workers/fix_14mib_d4_w8-3.cpu | 1 + .../workers/fix_14mib_d4_w8-3.json | 73 + .../results/lmcache_rust_connector_nvme.md | 166 ++ client-py/README.md | 6 + lmcache-connector/README.md | 11 +- 319 files changed, 40106 insertions(+), 5 deletions(-) create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/memory.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme1n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme2n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme3n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme4n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme1n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme2n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme3n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme4n1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure/results.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure_final/results.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_base.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_fix.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io14.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io16.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/main_upgrade/results.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_after.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_before.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/fill.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/iostat.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/load.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/monitor.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_after.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_before.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/store.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.cpu create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.json create mode 100644 benchmarks/results/lmcache_rust_connector_nvme.md diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 9476f46..9d3bda1 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -390,6 +390,17 @@ dataset = ShardedTokenDataset(["hypercache://datasets/tokens/shard_000.bin", ... loader = DataLoader(dataset, batch_size=16, num_workers=4) ``` +### 7.5. LMCache KV-Cache Connector + +`lmcache-connector/` is an L2 connector for LMCache's multiprocess mode, written in Rust and loaded through LMCache's `native_plugin` type. It's a separate package from the Python client. + +- **Control path:** each worker thread keeps a connection to the daemon's socket for `locate`, `stage_write` and `commit_write`. Commits are `LOCAL_ONLY`, so KV data is never flushed to a backend and stays evictable. +- **Data path:** workers read and write chunks directly on the devices the layout names, with `O_DIRECT` into LMCache's page-aligned L1 buffers, and verify a CRC32 per chunk on load. +- **Failure rule:** any doubt is a miss. A block that fails its checksum is evicted. If the daemon restarts, workers reconnect, and a request the daemon may have received is never resent. +- **Concurrency:** a worker handles one object at a time and reads its chunks in order, so `num_workers` sets the queue depth. + +See [`lmcache-connector/README.md`](lmcache-connector/README.md). + --- ## 8. CLI Command Reference & Operator Guide diff --git a/CHANGELOG.md b/CHANGELOG.md index 41be844..33e5dda 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,9 @@ back to the page cache for anything it can't take. Off by default. - `benchmarks/pipelined_ttft.py`, `benchmarks/write_concurrency_probe.py`, `benchmarks/raw_write_probe.py` and `benchmarks/results/lmcache_and_ttft.md`. -- `benchmarks/lmcache_connector_direct.py`, `benchmarks/results/lmcache_rust_connector.md` and - `benchmarks/results/lmcache_rust_connector_xeon.md`. +- `benchmarks/lmcache_connector_direct.py`, `benchmarks/results/lmcache_rust_connector.md`, + `benchmarks/results/lmcache_rust_connector_xeon.md` and + `benchmarks/results/lmcache_rust_connector_nvme.md`. ### Fixes - `HyperCacheKVStore` commits are now `LOCAL_ONLY` unless `write_through` is set. Previously every diff --git a/GETTING_STARTED.md b/GETTING_STARTED.md index 685d4b3..35e4fde 100644 --- a/GETTING_STARTED.md +++ b/GETTING_STARTED.md @@ -309,3 +309,35 @@ scrape_configs: 4. **Proxies and Sidecars**: If the controller sits behind a local proxy (Istio/Envoy sidecar, nginx, `kubectl port-forward`), set `allow_local_admin_bypass = false` in `hypercache-controller.toml`. Otherwise forwarded remote calls arrive from `127.0.0.1` and skip the token check. 5. **Restrict Filesystem Access**: `file://` and `nfs://` URIs may only reach `nfs_mount_path` and the directories listed in `nfs_allowed_paths`. Add dataset or checkpoint directories there explicitly instead of widening `nfs_mount_path` to `/`. 6. **Verify Before Rollout**: Run `scripts/verify_release.sh` on the build you deploy. It exercises the daemon, the fleet controller and a live S3 endpoint end to end. + +--- + +## 9. KV-Cache Storage for LMCache + +The connector in `lmcache-connector/` lets an LMCache server in multiprocess mode keep KV-cache chunks on HyperCache's NVMe tier. It's tested with LMCache 0.5.5 and 0.5.6. + +**1. Build and install it.** It isn't published as a package yet, so this needs a Rust toolchain and maturin. Use the same Python that runs LMCache: + +```bash +cd lmcache-connector +maturin build --release -i python3.12 +pip install target/wheels/hypercache_lmcache_native-*.whl +``` + +**2. Start the daemon** on the node, as in section 3. + +**3. Start LMCache with the connector:** + +```bash +lmcache server --l1-size-gb 60 --eviction-policy LRU --l1-align-bytes 4096 --l2-adapter '{ + "type": "native_plugin", + "module_path": "hypercache_lmcache_native", + "class_name": "HyperCacheNativeConnector", + "adapter_params": {"namespace": "my-model-rev-abc123", "tier": "nvme", "num_workers": 32}, + "max_capacity_gb": 0 +}' +``` + +Change `namespace` whenever the model weights, dtype or engine settings change, because LMCache's key has no model revision. Keep `max_capacity_gb` at 0, since the daemon owns capacity. Use `num_workers` 8 on one drive and 32 on four. + +The settings, behaviour and limits are in [`lmcache-connector/README.md`](lmcache-connector/README.md), and measurements are in [`benchmarks/results/lmcache_rust_connector_nvme.md`](benchmarks/results/lmcache_rust_connector_nvme.md). diff --git a/README.md b/README.md index 2f3745b..b9605df 100644 --- a/README.md +++ b/README.md @@ -712,7 +712,7 @@ lmcache server --l1-size-gb 60 --eviction-policy LRU --l2-adapter '{ - **Not supported:** `list_l2_keys` and LMCache's IsolatedLRU quotas. - **Size L1 for loads.** Loads go through L1, and LMCache only evicts it down to 80%. If the load doesn't fit, vLLM recomputes. -On a single drive, it ties LMCache's `raw_block` adapter on throughput while verifying a CRC32 on every chunk, though `raw_block` lookups are 5 to 10 times as fast. It can also stripe across drives, which `raw_block` can't: on a VM with 4 network disks it loaded at 6.4 GB/s, the VM's read limit, and at 39.8 GB/s from the RAM tier. See the [results](benchmarks/results/lmcache_rust_connector_xeon.md). +On 4 Gen4 NVMe drives it loads 14 MiB objects at 24.9 GB/s and stores them at 18.5 GB/s, while verifying a CRC32 on every chunk. That's 90% of the drives' raw read speed. LMCache's `raw_block` adapter uses one drive, where the two are about even on throughput, and its lookups are about 3 times as fast. See the [NVMe results](benchmarks/results/lmcache_rust_connector_nvme.md). For code that manages its own KV blocks, use `HyperCacheKVStore`: diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/memory.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/memory.txt new file mode 100644 index 0000000..02719d1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/memory.txt @@ -0,0 +1,28 @@ +crc32 threads 1: 59608 MB/s +memcpy threads 1: 47061 MB/s +tmpfs_read threads 1: 17962 MB/s +tmpfs_create threads 1: 2685 MB/s +crc32 threads 4: 236075 MB/s +memcpy threads 4: 182019 MB/s +tmpfs_read threads 4: 70604 MB/s +tmpfs_create threads 4: 10057 MB/s +crc32 threads 8: 451833 MB/s +memcpy threads 8: 379475 MB/s +tmpfs_read threads 8: 136927 MB/s +tmpfs_create threads 8: 18537 MB/s +crc32 threads 16: 852551 MB/s +memcpy threads 16: 717978 MB/s +tmpfs_read threads 16: 231772 MB/s +tmpfs_create threads 16: 20336 MB/s +crc32 threads 32: 973973 MB/s +memcpy threads 32: 1368923 MB/s +tmpfs_read threads 32: 299128 MB/s +tmpfs_create threads 32: 20103 MB/s +crc32 threads 48: 2257599 MB/s +memcpy threads 48: 1294905 MB/s +tmpfs_read threads 48: 267282 MB/s +tmpfs_create threads 48: 19671 MB/s +crc32 threads 96: 2648246 MB/s +memcpy threads 96: 545124 MB/s +tmpfs_read threads 96: 164717 MB/s +tmpfs_create threads 96: 17107 MB/s diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_1.json new file mode 100644 index 0000000..9e3016d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771142, + "timestamp_ms" : 1793771142420, + "time" : "Wed Nov 4 05:45:42 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771127360, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 103788052480, + "io_kbytes" : 101355520, + "bw_bytes" : 6910910406, + "bw" : 6748935, + "iops" : 1647.689439, + "runtime" : 15018, + "total_ios" : 24745, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 168401, + "max" : 2102108, + "mean" : 460021.256981, + "stddev" : 109034.436238, + "N" : 24745 + }, + "clat_ns" : { + "min" : 7721640, + "max" : 46947673, + "mean" : 18927560.726450, + "stddev" : 1107735.234560, + "N" : 24745, + "percentile" : { + "1.000000" : 17694720, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 18743296, + "30.000000" : 18743296, + "40.000000" : 18743296, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19005440, + "95.000000" : 19267584, + "99.000000" : 21102592, + "99.500000" : 25821184, + "99.900000" : 30539776, + "99.950000" : 34340864, + "99.990000" : 43778048 + } + }, + "lat_ns" : { + "min" : 8081897, + "max" : 49049781, + "mean" : 19387581.983431, + "stddev" : 1126113.549475, + "N" : 24745 + }, + "bw_min" : 6332416, + "bw_max" : 6791168, + "bw_agg" : 100.000000, + "bw_mean" : 6751684.517241, + "bw_dev" : 80941.363868, + "bw_samples" : 29, + "iops_min" : 1546, + "iops_max" : 1658, + "iops_mean" : 1648.000000, + "iops_stddev" : 19.704967, + "iops_samples" : 29 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.466138, + "sys_cpu" : 46.560565, + "ctx" : 59033, + "majf" : 0, + "minf" : 32782, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874722, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.226308, + "20" : 98.080420, + "50" : 1.693271, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 804998, + "write_ios" : 0, + "read_sectors" : 200785424, + "write_sectors" : 0, + "read_merges" : 2299, + "write_merges" : 0, + "read_ticks" : 14996434, + "write_ticks" : 0, + "in_queue" : 14996435, + "util" : 99.498261 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_2.json new file mode 100644 index 0000000..bb27de1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_2.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771235, + "timestamp_ms" : 1793771235126, + "time" : "Wed Nov 4 05:47:15 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771220076, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 103796441088, + "io_kbytes" : 101363712, + "bw_bytes" : 6911468976, + "bw" : 6749481, + "iops" : 1647.822613, + "runtime" : 15018, + "total_ios" : 24747, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 168930, + "max" : 2019057, + "mean" : 459795.655999, + "stddev" : 93439.641883, + "N" : 24747 + }, + "clat_ns" : { + "min" : 7775715, + "max" : 46307761, + "mean" : 18926687.312523, + "stddev" : 1116588.860539, + "N" : 24747, + "percentile" : { + "1.000000" : 17694720, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 18743296, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19005440, + "95.000000" : 19005440, + "99.000000" : 20578304, + "99.500000" : 25821184, + "99.900000" : 30801920, + "99.950000" : 34340864, + "99.990000" : 43253760 + } + }, + "lat_ns" : { + "min" : 8048396, + "max" : 48326818, + "mean" : 19386482.968521, + "stddev" : 1135078.437087, + "N" : 24747 + }, + "bw_min" : 6340608, + "bw_max" : 6782976, + "bw_agg" : 100.000000, + "bw_mean" : 6752459.724138, + "bw_dev" : 79455.210643, + "bw_samples" : 29, + "iops_min" : 1548, + "iops_max" : 1656, + "iops_mean" : 1648.068966, + "iops_stddev" : 19.327869, + "iops_samples" : 29 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.366252, + "sys_cpu" : 46.081108, + "ctx" : 61789, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874732, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.234372, + "20" : 98.516992, + "50" : 1.248636, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 802767, + "write_ios" : 0, + "read_sectors" : 200803344, + "write_sectors" : 0, + "read_merges" : 4607, + "write_merges" : 0, + "read_ticks" : 15018325, + "write_ticks" : 0, + "in_queue" : 15018324, + "util" : 99.498261 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_3.json new file mode 100644 index 0000000..2720152 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r1_3.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771327, + "timestamp_ms" : 1793771327846, + "time" : "Wed Nov 4 05:48:47 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771312797, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 103792246784, + "io_kbytes" : 101359616, + "bw_bytes" : 6911189691, + "bw" : 6749208, + "iops" : 1647.756026, + "runtime" : 15018, + "total_ios" : 24746, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 161140, + "max" : 1829962, + "mean" : 396959.616019, + "stddev" : 108476.055691, + "N" : 24746 + }, + "clat_ns" : { + "min" : 7621756, + "max" : 45658106, + "mean" : 18991503.719995, + "stddev" : 1122583.047310, + "N" : 24746, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19267584, + "95.000000" : 19529728, + "99.000000" : 20578304, + "99.500000" : 25559040, + "99.900000" : 30539776, + "99.950000" : 34340864, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 7867256, + "max" : 47306967, + "mean" : 19388463.336014, + "stddev" : 1136847.925231, + "N" : 24746 + }, + "bw_min" : 6348800, + "bw_max" : 6782976, + "bw_agg" : 99.934456, + "bw_mean" : 6744785.800000, + "bw_dev" : 82947.240261, + "bw_samples" : 30, + "iops_min" : 1550, + "iops_max" : 1656, + "iops_mean" : 1646.466667, + "iops_stddev" : 20.210501, + "iops_samples" : 30 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.312979, + "sys_cpu" : 46.853566, + "ctx" : 48634, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874727, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.242463, + "20" : 97.652146, + "50" : 2.105391, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 803517, + "write_ios" : 0, + "read_sectors" : 200798208, + "write_sectors" : 0, + "read_merges" : 6904, + "write_merges" : 0, + "read_ticks" : 14907398, + "write_ticks" : 0, + "in_queue" : 14907398, + "util" : 99.471572 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_1.json new file mode 100644 index 0000000..f3dbb9e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_1.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771157, + "timestamp_ms" : 1793771157819, + "time" : "Wed Nov 4 05:45:57 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771142759, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 207584493568, + "io_kbytes" : 202719232, + "bw_bytes" : 13822379382, + "bw" : 13498417, + "iops" : 3295.512052, + "runtime" : 15018, + "total_ios" : 49492, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 176712, + "max" : 2135085, + "mean" : 279209.197284, + "stddev" : 91207.448192, + "N" : 49492 + }, + "clat_ns" : { + "min" : 7951490, + "max" : 46702969, + "mean" : 19107637.260022, + "stddev" : 902957.828058, + "N" : 49492, + "percentile" : { + "1.000000" : 18219008, + "5.000000" : 18743296, + "10.000000" : 19005440, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19267584, + "80.000000" : 19267584, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 20316160, + "99.500000" : 21102592, + "99.900000" : 30801920, + "99.950000" : 34865152, + "99.990000" : 43778048 + } + }, + "lat_ns" : { + "min" : 8355631, + "max" : 48819835, + "mean" : 19386846.457306, + "stddev" : 914231.201841, + "N" : 49492 + }, + "bw_min" : 12681216, + "bw_max" : 13565952, + "bw_agg" : 100.000000, + "bw_mean" : 13513410.206897, + "bw_dev" : 79480.083221, + "bw_samples" : 58, + "iops_min" : 3096, + "iops_max" : 3312, + "iops_mean" : 3299.172414, + "iops_stddev" : 19.404317, + "iops_samples" : 58 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30034, + "usr_cpu" : 0.426184, + "sys_cpu" : 49.387361, + "ctx" : 53367, + "majf" : 0, + "minf" : 65558, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874727, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.157601, + "20" : 98.575527, + "50" : 1.266871, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 794426, + "write_ios" : 0, + "read_sectors" : 200630272, + "write_sectors" : 0, + "read_merges" : 14560, + "write_merges" : 0, + "read_ticks" : 14819176, + "write_ticks" : 0, + "in_queue" : 14819176, + "util" : 99.477597 + }, + { + "name" : "nvme2n1", + "read_ios" : 792926, + "write_ios" : 0, + "read_sectors" : 200635648, + "write_sectors" : 0, + "read_merges" : 10719, + "write_merges" : 0, + "read_ticks" : 14836545, + "write_ticks" : 0, + "in_queue" : 14836545, + "util" : 99.584395 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_2.json new file mode 100644 index 0000000..e780699 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_2.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771250, + "timestamp_ms" : 1793771250533, + "time" : "Wed Nov 4 05:47:30 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771235465, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 207584493568, + "io_kbytes" : 202719232, + "bw_bytes" : 13822379382, + "bw" : 13498417, + "iops" : 3295.512052, + "runtime" : 15018, + "total_ios" : 49492, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 167510, + "max" : 2074666, + "mean" : 349322.042977, + "stddev" : 81627.107515, + "N" : 49492 + }, + "clat_ns" : { + "min" : 7661230, + "max" : 47099658, + "mean" : 19037563.702841, + "stddev" : 961547.369198, + "N" : 49492, + "percentile" : { + "1.000000" : 18219008, + "5.000000" : 18743296, + "10.000000" : 19005440, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 20054016, + "99.500000" : 22675456, + "99.900000" : 30801920, + "99.950000" : 34340864, + "99.990000" : 44302336 + } + }, + "lat_ns" : { + "min" : 7886301, + "max" : 48969043, + "mean" : 19386885.745817, + "stddev" : 975237.475363, + "N" : 49492 + }, + "bw_min" : 12664832, + "bw_max" : 13565952, + "bw_agg" : 100.000000, + "bw_mean" : 13512477.586207, + "bw_dev" : 81040.074796, + "bw_samples" : 58, + "iops_min" : 3092, + "iops_max" : 3312, + "iops_mean" : 3298.896552, + "iops_stddev" : 19.784073, + "iops_samples" : 58 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30034, + "usr_cpu" : 0.462809, + "sys_cpu" : 56.366118, + "ctx" : 64031, + "majf" : 0, + "minf" : 65561, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874727, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.177807, + "20" : 98.789703, + "50" : 1.032490, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 796751, + "write_ios" : 0, + "read_sectors" : 200636944, + "write_sectors" : 0, + "read_merges" : 10726, + "write_merges" : 0, + "read_ticks" : 14928149, + "write_ticks" : 0, + "in_queue" : 14928148, + "util" : 99.497689 + }, + { + "name" : "nvme2n1", + "read_ios" : 793696, + "write_ios" : 0, + "read_sectors" : 200637912, + "write_sectors" : 0, + "read_merges" : 13022, + "write_merges" : 0, + "read_ticks" : 14802009, + "write_ticks" : 0, + "in_queue" : 14802009, + "util" : 99.577691 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_3.json new file mode 100644 index 0000000..4bf278e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r2_3.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771343, + "timestamp_ms" : 1793771343256, + "time" : "Wed Nov 4 05:49:03 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771328182, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 207584493568, + "io_kbytes" : 202719232, + "bw_bytes" : 13822379382, + "bw" : 13498417, + "iops" : 3295.512052, + "runtime" : 15018, + "total_ios" : 49492, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 173880, + "max" : 2142121, + "mean" : 342680.077083, + "stddev" : 98518.239518, + "N" : 49492 + }, + "clat_ns" : { + "min" : 7961113, + "max" : 46060464, + "mean" : 19044544.889578, + "stddev" : 892817.665394, + "N" : 49492, + "percentile" : { + "1.000000" : 17956864, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19267584, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 20054016, + "99.500000" : 20578304, + "99.900000" : 30539776, + "99.950000" : 34340864, + "99.990000" : 43253760 + } + }, + "lat_ns" : { + "min" : 8265114, + "max" : 48202585, + "mean" : 19387224.966661, + "stddev" : 904313.213883, + "N" : 49492 + }, + "bw_min" : 12681216, + "bw_max" : 13557760, + "bw_agg" : 100.000000, + "bw_mean" : 13513975.172414, + "bw_dev" : 79720.305792, + "bw_samples" : 58, + "iops_min" : 3096, + "iops_max" : 3310, + "iops_mean" : 3299.310345, + "iops_stddev" : 19.462965, + "iops_samples" : 58 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30034, + "usr_cpu" : 0.472797, + "sys_cpu" : 61.769994, + "ctx" : 47624, + "majf" : 0, + "minf" : 65560, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874727, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.157601, + "20" : 98.607856, + "50" : 1.234543, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 792845, + "write_ios" : 0, + "read_sectors" : 200615680, + "write_sectors" : 0, + "read_merges" : 14551, + "write_merges" : 0, + "read_ticks" : 14665026, + "write_ticks" : 0, + "in_queue" : 14665026, + "util" : 99.504320 + }, + { + "name" : "nvme2n1", + "read_ios" : 793742, + "write_ios" : 0, + "read_sectors" : 200648448, + "write_sectors" : 0, + "read_merges" : 14554, + "write_merges" : 0, + "read_ticks" : 14823534, + "write_ticks" : 0, + "in_queue" : 14823534, + "util" : 99.584339 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_1.json new file mode 100644 index 0000000..731179e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_1.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771173, + "timestamp_ms" : 1793771173263, + "time" : "Wed Nov 4 05:46:13 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771158196, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 415139627008, + "io_kbytes" : 405409792, + "bw_bytes" : 27642803769, + "bw" : 26994925, + "iops" : 6590.557997, + "runtime" : 15018, + "total_ios" : 98977, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 152931, + "max" : 2161844, + "mean" : 239344.587884, + "stddev" : 81132.177157, + "N" : 98977 + }, + "clat_ns" : { + "min" : 8011040, + "max" : 47503086, + "mean" : 19148459.019025, + "stddev" : 912078.484863, + "N" : 98977, + "percentile" : { + "1.000000" : 18219008, + "5.000000" : 18743296, + "10.000000" : 19005440, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19267584, + "60.000000" : 19267584, + "70.000000" : 19267584, + "80.000000" : 19267584, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 20054016, + "99.500000" : 21102592, + "99.900000" : 31064064, + "99.950000" : 34340864, + "99.990000" : 44302336 + } + }, + "lat_ns" : { + "min" : 8306752, + "max" : 49500208, + "mean" : 19387803.606909, + "stddev" : 924763.542802, + "N" : 98977 + }, + "bw_min" : 25346048, + "bw_max" : 27123712, + "bw_agg" : 99.967847, + "bw_mean" : 26986246.966667, + "bw_dev" : 81291.246710, + "bw_samples" : 120, + "iops_min" : 6188, + "iops_max" : 6622, + "iops_mean" : 6588.066667, + "iops_stddev" : 19.830966, + "iops_samples" : 120 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60068, + "usr_cpu" : 0.426184, + "sys_cpu" : 49.086036, + "ctx" : 94813, + "majf" : 0, + "minf" : 131123, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874718, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.157612, + "20" : 98.594623, + "50" : 1.247765, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 789955, + "write_ios" : 0, + "read_sectors" : 200467200, + "write_sectors" : 0, + "read_merges" : 6895, + "write_merges" : 0, + "read_ticks" : 14754783, + "write_ticks" : 0, + "in_queue" : 14754783, + "util" : 99.145014 + }, + { + "name" : "nvme2n1", + "read_ios" : 786160, + "write_ios" : 0, + "read_sectors" : 200474112, + "write_sectors" : 0, + "read_merges" : 9958, + "write_merges" : 0, + "read_ticks" : 14683742, + "write_ticks" : 0, + "in_queue" : 14683742, + "util" : 99.204492 + }, + { + "name" : "nvme3n1", + "read_ios" : 789148, + "write_ios" : 0, + "read_sectors" : 200455672, + "write_sectors" : 0, + "read_merges" : 8424, + "write_merges" : 0, + "read_ticks" : 14709327, + "write_ticks" : 0, + "in_queue" : 14709328, + "util" : 99.264214 + }, + { + "name" : "nvme4n1", + "read_ios" : 788531, + "write_ios" : 0, + "read_sectors" : 200492288, + "write_sectors" : 0, + "read_merges" : 9186, + "write_merges" : 0, + "read_ticks" : 14724376, + "write_ticks" : 0, + "in_queue" : 14724377, + "util" : 99.450513 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_2.json new file mode 100644 index 0000000..b35ed01 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_2.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771265, + "timestamp_ms" : 1793771265980, + "time" : "Wed Nov 4 05:47:45 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771250909, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 415152209920, + "io_kbytes" : 405422080, + "bw_bytes" : 27643641624, + "bw" : 26995743, + "iops" : 6590.757757, + "runtime" : 15018, + "total_ios" : 98980, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 156751, + "max" : 1995044, + "mean" : 243233.894241, + "stddev" : 83759.493904, + "N" : 98980 + }, + "clat_ns" : { + "min" : 8032887, + "max" : 47642446, + "mean" : 19143797.488594, + "stddev" : 837926.106692, + "N" : 98980, + "percentile" : { + "1.000000" : 18481152, + "5.000000" : 19005440, + "10.000000" : 19005440, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19267584, + "60.000000" : 19267584, + "70.000000" : 19267584, + "80.000000" : 19267584, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 19791872, + "99.500000" : 20316160, + "99.900000" : 30539776, + "99.950000" : 34340864, + "99.990000" : 44302336 + } + }, + "lat_ns" : { + "min" : 8558859, + "max" : 49521450, + "mean" : 19387031.382835, + "stddev" : 852112.399745, + "N" : 98980 + }, + "bw_min" : 25329664, + "bw_max" : 27134716, + "bw_agg" : 99.961172, + "bw_mean" : 26985262.033333, + "bw_dev" : 82422.795251, + "bw_samples" : 120, + "iops_min" : 6184, + "iops_max" : 6624, + "iops_mean" : 6587.733333, + "iops_stddev" : 20.102092, + "iops_samples" : 120 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60067, + "usr_cpu" : 0.421196, + "sys_cpu" : 50.158989, + "ctx" : 96049, + "majf" : 0, + "minf" : 131123, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874722, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.141443, + "20" : 99.070519, + "50" : 0.788038, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 789892, + "write_ios" : 0, + "read_sectors" : 200449288, + "write_sectors" : 0, + "read_merges" : 5357, + "write_merges" : 0, + "read_ticks" : 14808025, + "write_ticks" : 0, + "in_queue" : 14808025, + "util" : 99.144785 + }, + { + "name" : "nvme2n1", + "read_ios" : 788350, + "write_ios" : 0, + "read_sectors" : 200447488, + "write_sectors" : 0, + "read_merges" : 6126, + "write_merges" : 0, + "read_ticks" : 14768177, + "write_ticks" : 0, + "in_queue" : 14768177, + "util" : 99.224288 + }, + { + "name" : "nvme3n1", + "read_ios" : 788399, + "write_ios" : 0, + "read_sectors" : 200458224, + "write_sectors" : 0, + "read_merges" : 7658, + "write_merges" : 0, + "read_ticks" : 14745247, + "write_ticks" : 0, + "in_queue" : 14745247, + "util" : 99.257475 + }, + { + "name" : "nvme4n1", + "read_ios" : 787675, + "write_ios" : 0, + "read_sectors" : 200470016, + "write_sectors" : 0, + "read_merges" : 6892, + "write_merges" : 0, + "read_ticks" : 14706363, + "write_ticks" : 0, + "in_queue" : 14706363, + "util" : 99.430333 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_3.json new file mode 100644 index 0000000..d822c7f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r4_3.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771358, + "timestamp_ms" : 1793771358701, + "time" : "Wed Nov 4 05:49:18 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771343628, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 415114461184, + "io_kbytes" : 405385216, + "bw_bytes" : 27641128058, + "bw" : 26993289, + "iops" : 6590.158476, + "runtime" : 15018, + "total_ios" : 98971, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 157110, + "max" : 2152500, + "mean" : 236003.082822, + "stddev" : 81210.823488, + "N" : 98971 + }, + "clat_ns" : { + "min" : 7814391, + "max" : 47134723, + "mean" : 19153138.916905, + "stddev" : 939213.959963, + "N" : 98971, + "percentile" : { + "1.000000" : 18219008, + "5.000000" : 18743296, + "10.000000" : 19005440, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19267584, + "60.000000" : 19267584, + "70.000000" : 19267584, + "80.000000" : 19267584, + "90.000000" : 19267584, + "95.000000" : 19267584, + "99.000000" : 20316160, + "99.500000" : 21889024, + "99.900000" : 30801920, + "99.950000" : 34865152, + "99.990000" : 44302336 + } + }, + "lat_ns" : { + "min" : 8325451, + "max" : 49287223, + "mean" : 19389141.999727, + "stddev" : 950760.651112, + "N" : 98971 + }, + "bw_min" : 25337856, + "bw_max" : 27131904, + "bw_agg" : 100.000000, + "bw_mean" : 27009183.034483, + "bw_dev" : 79847.235973, + "bw_samples" : 116, + "iops_min" : 6186, + "iops_max" : 6624, + "iops_mean" : 6593.172414, + "iops_stddev" : 19.469054, + "iops_samples" : 116 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60068, + "usr_cpu" : 0.479457, + "sys_cpu" : 48.588267, + "ctx" : 94564, + "majf" : 0, + "minf" : 131129, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874711, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.168736, + "20" : 98.541997, + "50" : 1.289267, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 788291, + "write_ios" : 0, + "read_sectors" : 200237824, + "write_sectors" : 0, + "read_merges" : 6886, + "write_merges" : 0, + "read_ticks" : 14648502, + "write_ticks" : 0, + "in_queue" : 14648502, + "util" : 99.104218 + }, + { + "name" : "nvme2n1", + "read_ios" : 787781, + "write_ios" : 0, + "read_sectors" : 200301840, + "write_sectors" : 0, + "read_merges" : 6885, + "write_merges" : 0, + "read_ticks" : 14739952, + "write_ticks" : 0, + "in_queue" : 14739952, + "util" : 99.197110 + }, + { + "name" : "nvme3n1", + "read_ios" : 787712, + "write_ios" : 0, + "read_sectors" : 200282640, + "write_sectors" : 0, + "read_merges" : 6119, + "write_merges" : 0, + "read_ticks" : 14711334, + "write_ticks" : 0, + "in_queue" : 14711334, + "util" : 99.256978 + }, + { + "name" : "nvme4n1", + "read_ios" : 787006, + "write_ios" : 0, + "read_sectors" : 200299776, + "write_sectors" : 0, + "read_merges" : 7654, + "write_merges" : 0, + "read_ticks" : 14714457, + "write_ticks" : 0, + "in_queue" : 14714457, + "util" : 99.429989 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme1n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme1n1.json new file mode 100644 index 0000000..dbca906 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme1n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793770988, + "timestamp_ms" : 1793770988058, + "time" : "Wed Nov 4 05:43:08 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793770973006, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 102626230272, + "io_kbytes" : 100220928, + "bw_bytes" : 6833093433, + "bw" : 6672942, + "iops" : 1629.136427, + "runtime" : 15019, + "total_ios" : 24468, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 198186, + "max" : 1840448, + "mean" : 269458.863373, + "stddev" : 63583.587930, + "N" : 24468 + }, + "clat_ns" : { + "min" : 8164246, + "max" : 48484122, + "mean" : 19338138.364844, + "stddev" : 1237665.230345, + "N" : 24468, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19267584, + "60.000000" : 19529728, + "70.000000" : 20054016, + "80.000000" : 20316160, + "90.000000" : 20578304, + "95.000000" : 20840448, + "99.000000" : 21626880, + "99.500000" : 22151168, + "99.900000" : 31064064, + "99.950000" : 35389440, + "99.990000" : 45350912 + } + }, + "lat_ns" : { + "min" : 8676830, + "max" : 50224067, + "mean" : 19607597.228216, + "stddev" : 1247945.849328, + "N" : 24468 + }, + "bw_min" : 6242304, + "bw_max" : 6720383, + "bw_agg" : 100.000000, + "bw_mean" : 6673885.275862, + "bw_dev" : 84665.631589, + "bw_samples" : 29, + "iops_min" : 1524, + "iops_max" : 1640, + "iops_mean" : 1628.758621, + "iops_stddev" : 20.573310, + "iops_samples" : 29 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15018, + "usr_cpu" : 0.273006, + "sys_cpu" : 46.530830, + "ctx" : 16791, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.873304, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995908, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.118522, + "20" : 71.955207, + "50" : 27.926271, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 786206, + "write_ios" : 0, + "read_sectors" : 198555664, + "write_sectors" : 0, + "read_merges" : 2275, + "write_merges" : 0, + "read_ticks" : 13999944, + "write_ticks" : 0, + "in_queue" : 13999944, + "util" : 99.504950 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme2n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme2n1.json new file mode 100644 index 0000000..c3dbc0d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme2n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771018, + "timestamp_ms" : 1793771018872, + "time" : "Wed Nov 4 05:43:38 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme2n1", + "groupid" : 0, + "job_start" : 1793771003821, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 103469285376, + "io_kbytes" : 101044224, + "bw_bytes" : 6889684736, + "bw" : 6728207, + "iops" : 1642.628845, + "runtime" : 15018, + "total_ios" : 24669, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 194945, + "max" : 2077302, + "mean" : 372015.996919, + "stddev" : 120600.135397, + "N" : 24669 + }, + "clat_ns" : { + "min" : 7702850, + "max" : 47924261, + "mean" : 19074801.641534, + "stddev" : 975451.090957, + "N" : 24669, + "percentile" : { + "1.000000" : 17694720, + "5.000000" : 18219008, + "10.000000" : 18743296, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19267584, + "90.000000" : 20054016, + "95.000000" : 20316160, + "99.000000" : 21102592, + "99.500000" : 21364736, + "99.900000" : 30539776, + "99.950000" : 34340864, + "99.990000" : 44826624 + } + }, + "lat_ns" : { + "min" : 8018938, + "max" : 50001563, + "mean" : 19446817.638453, + "stddev" : 982917.537429, + "N" : 24669 + }, + "bw_min" : 6234112, + "bw_max" : 6774784, + "bw_agg" : 99.967380, + "bw_mean" : 6726013.466667, + "bw_dev" : 103527.661045, + "bw_samples" : 30, + "iops_min" : 1522, + "iops_max" : 1654, + "iops_mean" : 1642.000000, + "iops_stddev" : 25.243640, + "iops_samples" : 30 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.312979, + "sys_cpu" : 45.654924, + "ctx" : 44031, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874336, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995941, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.133771, + "20" : 90.546840, + "50" : 9.319389, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme2n1", + "read_ios" : 799986, + "write_ios" : 0, + "read_sectors" : 200297736, + "write_sectors" : 0, + "read_merges" : 2296, + "write_merges" : 0, + "read_ticks" : 14754647, + "write_ticks" : 0, + "in_queue" : 14754648, + "util" : 99.511967 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme3n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme3n1.json new file mode 100644 index 0000000..b12373a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme3n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771049, + "timestamp_ms" : 1793771049683, + "time" : "Wed Nov 4 05:44:09 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme3n1", + "groupid" : 0, + "job_start" : 1793771034632, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme3n1", + "filename" : "/dev/nvme3n1" + }, + "read" : { + "io_bytes" : 103783858176, + "io_kbytes" : 101351424, + "bw_bytes" : 6910631121, + "bw" : 6748663, + "iops" : 1647.622853, + "runtime" : 15018, + "total_ios" : 24744, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 197834, + "max" : 1835844, + "mean" : 390745.736502, + "stddev" : 102408.822482, + "N" : 24744 + }, + "clat_ns" : { + "min" : 7768054, + "max" : 47787687, + "mean" : 18996843.786049, + "stddev" : 1232833.944883, + "N" : 24744, + "percentile" : { + "1.000000" : 16056320, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 19005440, + "30.000000" : 19005440, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19005440, + "95.000000" : 19267584, + "99.000000" : 22413312, + "99.500000" : 27131904, + "99.900000" : 30801920, + "99.950000" : 34340864, + "99.990000" : 44826624 + } + }, + "lat_ns" : { + "min" : 8254687, + "max" : 49424368, + "mean" : 19387589.522551, + "stddev" : 1247449.486175, + "N" : 24744 + }, + "bw_min" : 6332416, + "bw_max" : 6782976, + "bw_agg" : 100.000000, + "bw_mean" : 6750030.620690, + "bw_dev" : 80535.019790, + "bw_samples" : 29, + "iops_min" : 1546, + "iops_max" : 1656, + "iops_mean" : 1647.379310, + "iops_stddev" : 19.567491, + "iops_samples" : 29 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.233069, + "sys_cpu" : 48.265299, + "ctx" : 47437, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874717, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.295021, + "20" : 98.197543, + "50" : 1.507436, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme3n1", + "read_ios" : 802103, + "write_ios" : 0, + "read_sectors" : 201019392, + "write_sectors" : 0, + "read_merges" : 766, + "write_merges" : 0, + "read_ticks" : 15008863, + "write_ticks" : 0, + "in_queue" : 15008864, + "util" : 99.518877 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme4n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme4n1.json new file mode 100644 index 0000000..f4e0f9f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/r_nvme4n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771080, + "timestamp_ms" : 1793771080537, + "time" : "Wed Nov 4 05:44:40 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "read", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme4n1", + "groupid" : 0, + "job_start" : 1793771065475, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 103788052480, + "io_kbytes" : 101355520, + "bw_bytes" : 6910910406, + "bw" : 6748935, + "iops" : 1647.689439, + "runtime" : 15018, + "total_ios" : 24745, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 197273, + "max" : 2088150, + "mean" : 439231.284017, + "stddev" : 102343.388457, + "N" : 24745 + }, + "clat_ns" : { + "min" : 7997199, + "max" : 47833617, + "mean" : 18947962.511376, + "stddev" : 1197080.657344, + "N" : 24745, + "percentile" : { + "1.000000" : 16580608, + "5.000000" : 18743296, + "10.000000" : 18743296, + "20.000000" : 18743296, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19005440, + "70.000000" : 19005440, + "80.000000" : 19005440, + "90.000000" : 19005440, + "95.000000" : 19005440, + "99.000000" : 21626880, + "99.500000" : 26607616, + "99.900000" : 31064064, + "99.950000" : 34340864, + "99.990000" : 44826624 + } + }, + "lat_ns" : { + "min" : 8410482, + "max" : 49921767, + "mean" : 19387193.795393, + "stddev" : 1214847.113476, + "N" : 24745 + }, + "bw_min" : 6324224, + "bw_max" : 6774784, + "bw_agg" : 100.000000, + "bw_mean" : 6749451.068966, + "bw_dev" : 81917.179631, + "bw_samples" : 29, + "iops_min" : 1544, + "iops_max" : 1654, + "iops_mean" : 1647.310345, + "iops_stddev" : 19.908906, + "iops_samples" : 29 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15017, + "usr_cpu" : 0.372911, + "sys_cpu" : 47.765865, + "ctx" : 55785, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.874722, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.995954, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.274803, + "20" : 98.419883, + "50" : 1.305314, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme4n1", + "read_ios" : 803906, + "write_ios" : 0, + "read_sectors" : 200704264, + "write_sectors" : 0, + "read_merges" : 3065, + "write_merges" : 0, + "read_ticks" : 15014560, + "write_ticks" : 0, + "in_queue" : 15014560, + "util" : 99.518137 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_1.json new file mode 100644 index 0000000..0d7e394 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771096, + "timestamp_ms" : 1793771096015, + "time" : "Wed Nov 4 05:44:56 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771080934, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80941678592, + "io_kbytes" : 79044608, + "bw_bytes" : 5386416356, + "bw" : 5260172, + "iops" : 1284.221734, + "runtime" : 15027, + "total_ios" : 19298, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 216093, + "max" : 1656050, + "mean" : 688145.941497, + "stddev" : 165622.477711, + "N" : 19298 + }, + "clat_ns" : { + "min" : 9396232, + "max" : 51490667, + "mean" : 24217930.030366, + "stddev" : 2144163.361237, + "N" : 19298, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 21626880, + "10.000000" : 21626880, + "20.000000" : 22413312, + "30.000000" : 22675456, + "40.000000" : 23724032, + "50.000000" : 24248320, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 25821184, + "90.000000" : 26345472, + "95.000000" : 26869760, + "99.000000" : 27918336, + "99.500000" : 30015488, + "99.900000" : 39583744, + "99.950000" : 43778048, + "99.990000" : 50593792 + } + }, + "lat_ns" : { + "min" : 9911308, + "max" : 52256165, + "mean" : 24906075.971862, + "stddev" : 2193236.265336, + "N" : 19298 + }, + "bw_min" : 4939776, + "bw_max" : 5788359, + "bw_agg" : 100.000000, + "bw_mean" : 5268077.137931, + "bw_dev" : 264351.187033, + "bw_samples" : 29, + "iops_min" : 1206, + "iops_max" : 1413, + "iops_mean" : 1285.965517, + "iops_stddev" : 64.575804, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15026, + "usr_cpu" : 14.168774, + "sys_cpu" : 31.731665, + "ctx" : 50426, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839362, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994810, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010364, + "20" : 0.668463, + "50" : 99.310809, + "100" : 0.010364, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 624044, + "read_sectors" : 0, + "write_sectors" : 155948800, + "read_merges" : 0, + "write_merges" : 1785, + "read_ticks" : 0, + "write_ticks" : 15044172, + "in_queue" : 15044172, + "util" : 99.063420 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_2.json new file mode 100644 index 0000000..16e526b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_2.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771188, + "timestamp_ms" : 1793771188734, + "time" : "Wed Nov 4 05:46:28 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771173659, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 81688264704, + "io_kbytes" : 79773696, + "bw_bytes" : 5437184817, + "bw" : 5309750, + "iops" : 1296.325879, + "runtime" : 15024, + "total_ios" : 19476, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 189611, + "max" : 1773810, + "mean" : 712553.967961, + "stddev" : 153609.677199, + "N" : 19476 + }, + "clat_ns" : { + "min" : 9651986, + "max" : 45537820, + "mean" : 23961757.727100, + "stddev" : 1960674.955567, + "N" : 19476, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 21364736, + "10.000000" : 21626880, + "20.000000" : 22413312, + "30.000000" : 22675456, + "40.000000" : 23461888, + "50.000000" : 24248320, + "60.000000" : 24510464, + "70.000000" : 25034752, + "80.000000" : 25559040, + "90.000000" : 26083328, + "95.000000" : 26607616, + "99.000000" : 27656192, + "99.500000" : 28442624, + "99.900000" : 39059456, + "99.950000" : 41156608, + "99.990000" : 44826624 + } + }, + "lat_ns" : { + "min" : 10024237, + "max" : 46210503, + "mean" : 24674311.695061, + "stddev" : 2005123.180972, + "N" : 19476 + }, + "bw_min" : 5011672, + "bw_max" : 5799936, + "bw_agg" : 100.000000, + "bw_mean" : 5324836.586207, + "bw_dev" : 246062.841958, + "bw_samples" : 29, + "iops_min" : 1223, + "iops_max" : 1416, + "iops_mean" : 1299.965517, + "iops_stddev" : 60.092478, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15023, + "usr_cpu" : 14.624243, + "sys_cpu" : 28.662717, + "ctx" : 52521, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.840830, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994858, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010269, + "20" : 0.518587, + "50" : 99.471144, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 630875, + "read_sectors" : 0, + "write_sectors" : 157356024, + "read_merges" : 0, + "write_merges" : 1805, + "read_ticks" : 0, + "write_ticks" : 15056002, + "in_queue" : 15056002, + "util" : 99.083489 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_3.json new file mode 100644 index 0000000..d16d71e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w1_3.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771281, + "timestamp_ms" : 1793771281442, + "time" : "Wed Nov 4 05:48:01 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771266373, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 81096867840, + "io_kbytes" : 79196160, + "bw_bytes" : 5398180645, + "bw" : 5271660, + "iops" : 1287.026559, + "runtime" : 15023, + "total_ios" : 19335, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 188210, + "max" : 1684643, + "mean" : 713981.374864, + "stddev" : 153784.223812, + "N" : 19335 + }, + "clat_ns" : { + "min" : 9960686, + "max" : 43446252, + "mean" : 24139470.031342, + "stddev" : 2043126.667496, + "N" : 19335, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 21889024, + "10.000000" : 22151168, + "20.000000" : 22151168, + "30.000000" : 22675456, + "40.000000" : 23461888, + "50.000000" : 24248320, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25821184, + "90.000000" : 26345472, + "95.000000" : 26869760, + "99.000000" : 29491200, + "99.500000" : 29491200, + "99.900000" : 38535168, + "99.950000" : 39583744, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 10490647, + "max" : 44088223, + "mean" : 24853451.406206, + "stddev" : 2096027.257031, + "N" : 19335 + }, + "bw_min" : 4947968, + "bw_max" : 5718016, + "bw_agg" : 100.000000, + "bw_mean" : 5272405.206897, + "bw_dev" : 236934.655985, + "bw_samples" : 29, + "iops_min" : 1208, + "iops_max" : 1396, + "iops_mean" : 1287.034483, + "iops_stddev" : 57.888120, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15022, + "usr_cpu" : 13.986154, + "sys_cpu" : 28.564772, + "ctx" : 53160, + "majf" : 0, + "minf" : 11, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839669, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994820, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.558573, + "50" : 99.436255, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 625209, + "read_sectors" : 0, + "write_sectors" : 155942912, + "read_merges" : 0, + "write_merges" : 3575, + "read_ticks" : 0, + "write_ticks" : 15055914, + "in_queue" : 15055915, + "util" : 99.076800 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_1.json new file mode 100644 index 0000000..f934f11 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_1.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771111, + "timestamp_ms" : 1793771111510, + "time" : "Wed Nov 4 05:45:11 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771096423, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 162738995200, + "io_kbytes" : 158924800, + "bw_bytes" : 10829772755, + "bw" : 10575949, + "iops" : 2582.019032, + "runtime" : 15027, + "total_ios" : 38800, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 195832, + "max" : 1388234, + "mean" : 484904.440077, + "stddev" : 110719.883214, + "N" : 38800 + }, + "clat_ns" : { + "min" : 9510550, + "max" : 51771582, + "mean" : 24287679.187629, + "stddev" : 2063801.626903, + "N" : 38800, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 21889024, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23724032, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25821184, + "90.000000" : 26607616, + "95.000000" : 27131904, + "99.000000" : 29491200, + "99.500000" : 29753344, + "99.900000" : 39059456, + "99.950000" : 42205184, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 9978105, + "max" : 52222196, + "mean" : 24772583.627706, + "stddev" : 2097228.078796, + "N" : 38800 + }, + "bw_min" : 9773056, + "bw_max" : 11517952, + "bw_agg" : 100.000000, + "bw_mean" : 10578056.533333, + "bw_dev" : 251057.631164, + "bw_samples" : 60, + "iops_min" : 2386, + "iops_max" : 2812, + "iops_mean" : 2582.533333, + "iops_stddev" : 61.293367, + "iops_samples" : 60 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30048, + "usr_cpu" : 16.896299, + "sys_cpu" : 44.968051, + "ctx" : 43843, + "majf" : 0, + "minf" : 24, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.840206, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994837, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.551546, + "50" : 99.435567, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 622136, + "read_sectors" : 0, + "write_sectors" : 157118688, + "read_merges" : 0, + "write_merges" : 6005, + "read_ticks" : 0, + "write_ticks" : 14867222, + "in_queue" : 14867223, + "util" : 99.102478 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 618951, + "read_sectors" : 0, + "write_sectors" : 156165888, + "read_merges" : 0, + "write_merges" : 8957, + "read_ticks" : 0, + "write_ticks" : 14873930, + "in_queue" : 14873930, + "util" : 99.188845 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_2.json new file mode 100644 index 0000000..b58b8fc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_2.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771204, + "timestamp_ms" : 1793771204227, + "time" : "Wed Nov 4 05:46:44 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771189141, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 163607216128, + "io_kbytes" : 159772672, + "bw_bytes" : 10888999409, + "bw" : 10633788, + "iops" : 2596.139767, + "runtime" : 15025, + "total_ios" : 39007, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 191881, + "max" : 1328455, + "mean" : 466454.537339, + "stddev" : 98048.826328, + "N" : 39007 + }, + "clat_ns" : { + "min" : 10032160, + "max" : 47921476, + "mean" : 24173024.095367, + "stddev" : 2056265.660103, + "N" : 39007, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 21626880, + "10.000000" : 21889024, + "20.000000" : 22413312, + "30.000000" : 22675456, + "40.000000" : 23199744, + "50.000000" : 24248320, + "60.000000" : 24772608, + "70.000000" : 25296896, + "80.000000" : 25821184, + "90.000000" : 26607616, + "95.000000" : 26869760, + "99.000000" : 28704768, + "99.500000" : 32636928, + "99.900000" : 38535168, + "99.950000" : 41156608, + "99.990000" : 45350912 + } + }, + "lat_ns" : { + "min" : 10542842, + "max" : 48342557, + "mean" : 24639478.632707, + "stddev" : 2084055.035389, + "N" : 39007 + }, + "bw_min" : 9732096, + "bw_max" : 11493376, + "bw_agg" : 100.000000, + "bw_mean" : 10634951.233333, + "bw_dev" : 240416.942751, + "bw_samples" : 60, + "iops_min" : 2376, + "iops_max" : 2806, + "iops_mean" : 2596.400000, + "iops_stddev" : 58.685218, + "iops_samples" : 60 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30046, + "usr_cpu" : 17.123744, + "sys_cpu" : 44.158956, + "ctx" : 42887, + "majf" : 0, + "minf" : 23, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.841054, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994865, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.438383, + "50" : 99.561617, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 624729, + "read_sectors" : 0, + "write_sectors" : 157925888, + "read_merges" : 0, + "write_merges" : 8451, + "read_ticks" : 0, + "write_ticks" : 14853722, + "in_queue" : 14853723, + "util" : 99.095962 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 620153, + "read_sectors" : 0, + "write_sectors" : 156618240, + "read_merges" : 0, + "write_merges" : 10175, + "read_ticks" : 0, + "write_ticks" : 14863553, + "in_queue" : 14863552, + "util" : 99.189008 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_3.json new file mode 100644 index 0000000..70ab024 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w2_3.json @@ -0,0 +1,290 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771296, + "timestamp_ms" : 1793771296934, + "time" : "Wed Nov 4 05:48:16 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771281848, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 162789326848, + "io_kbytes" : 158973952, + "bw_bytes" : 10833122169, + "bw" : 10579220, + "iops" : 2582.817595, + "runtime" : 15027, + "total_ios" : 38812, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 200230, + "max" : 1275962, + "mean" : 472707.630759, + "stddev" : 82367.841774, + "N" : 38812 + }, + "clat_ns" : { + "min" : 9243550, + "max" : 51268766, + "mean" : 24294104.032335, + "stddev" : 2055134.203377, + "N" : 38812, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22151168, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23461888, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25821184, + "90.000000" : 26607616, + "95.000000" : 27131904, + "99.000000" : 29229056, + "99.500000" : 30277632, + "99.900000" : 38010880, + "99.950000" : 41680896, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 9776791, + "max" : 51770206, + "mean" : 24766811.663094, + "stddev" : 2069183.159813, + "N" : 38812 + }, + "bw_min" : 9715712, + "bw_max" : 11460608, + "bw_agg" : 100.000000, + "bw_mean" : 10581697.233333, + "bw_dev" : 243844.733270, + "bw_samples" : 60, + "iops_min" : 2372, + "iops_max" : 2798, + "iops_mean" : 2583.400000, + "iops_stddev" : 59.525753, + "iops_samples" : 60 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30050, + "usr_cpu" : 17.188020, + "sys_cpu" : 44.475874, + "ctx" : 41857, + "majf" : 0, + "minf" : 27, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.840256, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994839, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.543646, + "50" : 99.443471, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 617656, + "read_sectors" : 0, + "write_sectors" : 155988992, + "read_merges" : 0, + "write_merges" : 11330, + "read_ticks" : 0, + "write_ticks" : 14864337, + "in_queue" : 14864338, + "util" : 99.115815 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 620764, + "read_sectors" : 0, + "write_sectors" : 157074688, + "read_merges" : 0, + "write_merges" : 10802, + "read_ticks" : 0, + "write_ticks" : 14823227, + "in_queue" : 14823227, + "util" : 99.195549 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_1.json new file mode 100644 index 0000000..b14568e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_1.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771127, + "timestamp_ms" : 1793771127036, + "time" : "Wed Nov 4 05:45:27 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771111957, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 323527639040, + "io_kbytes" : 315944960, + "bw_bytes" : 21531188542, + "bw" : 21026551, + "iops" : 5133.435379, + "runtime" : 15026, + "total_ios" : 77135, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 174342, + "max" : 1156421, + "mean" : 440153.403747, + "stddev" : 88595.010749, + "N" : 77135 + }, + "clat_ns" : { + "min" : 9341598, + "max" : 48701461, + "mean" : 24480444.360796, + "stddev" : 2491364.678234, + "N" : 77135, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 21889024, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23461888, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 26083328, + "90.000000" : 26869760, + "95.000000" : 27918336, + "99.000000" : 32899072, + "99.500000" : 37486592, + "99.900000" : 39059456, + "99.950000" : 41680896, + "99.990000" : 45350912 + } + }, + "lat_ns" : { + "min" : 9997574, + "max" : 49007314, + "mean" : 24920597.764543, + "stddev" : 2500184.941003, + "N" : 77135 + }, + "bw_min" : 18357094, + "bw_max" : 22937600, + "bw_agg" : 99.992841, + "bw_mean" : 21025046.448276, + "bw_dev" : 309566.946096, + "bw_samples" : 116, + "iops_min" : 4481, + "iops_max" : 5600, + "iops_mean" : 5132.172414, + "iops_stddev" : 75.594936, + "iops_samples" : 116 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60092, + "usr_cpu" : 17.960793, + "sys_cpu" : 43.962591, + "ctx" : 75992, + "majf" : 0, + "minf" : 54, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839243, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994806, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.672846, + "50" : 99.323264, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 618760, + "read_sectors" : 0, + "write_sectors" : 157174784, + "read_merges" : 0, + "write_merges" : 8407, + "read_ticks" : 0, + "write_ticks" : 14758990, + "in_queue" : 14758991, + "util" : 98.724711 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 619345, + "read_sectors" : 0, + "write_sectors" : 157019392, + "read_merges" : 0, + "write_merges" : 5994, + "read_ticks" : 0, + "write_ticks" : 14786437, + "in_queue" : 14786437, + "util" : 98.823765 + }, + { + "name" : "nvme3n1", + "read_ios" : 0, + "write_ios" : 602696, + "read_sectors" : 0, + "write_sectors" : 153094656, + "read_merges" : 0, + "write_merges" : 7025, + "read_ticks" : 0, + "write_ticks" : 14754033, + "in_queue" : 14754032, + "util" : 98.870019 + }, + { + "name" : "nvme4n1", + "read_ios" : 0, + "write_ios" : 607231, + "read_sectors" : 0, + "write_sectors" : 154246656, + "read_merges" : 0, + "write_merges" : 8255, + "read_ticks" : 0, + "write_ticks" : 14761329, + "in_queue" : 14761329, + "util" : 99.068864 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_2.json new file mode 100644 index 0000000..851657c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_2.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771219, + "timestamp_ms" : 1793771219750, + "time" : "Wed Nov 4 05:46:59 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771204668, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 324291002368, + "io_kbytes" : 316690432, + "bw_bytes" : 21576247662, + "bw" : 21070554, + "iops" : 5144.178310, + "runtime" : 15030, + "total_ios" : 77317, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 171890, + "max" : 1205234, + "mean" : 425678.464193, + "stddev" : 75377.046508, + "N" : 77317 + }, + "clat_ns" : { + "min" : 9349015, + "max" : 58164491, + "mean" : 24441224.672608, + "stddev" : 2166128.838848, + "N" : 77317, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 21889024, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23724032, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 26083328, + "90.000000" : 26869760, + "95.000000" : 27131904, + "99.000000" : 30015488, + "99.500000" : 32636928, + "99.900000" : 39583744, + "99.950000" : 43778048, + "99.990000" : 51642368 + } + }, + "lat_ns" : { + "min" : 9824426, + "max" : 58593102, + "mean" : 24866903.136801, + "stddev" : 2170727.125915, + "N" : 77317 + }, + "bw_min" : 19331255, + "bw_max" : 22917847, + "bw_agg" : 100.000000, + "bw_mean" : 21140904.000000, + "bw_dev" : 255983.213939, + "bw_samples" : 116, + "iops_min" : 4719, + "iops_max" : 5595, + "iops_mean" : 5160.827586, + "iops_stddev" : 62.494387, + "iops_samples" : 116 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60104, + "usr_cpu" : 18.492946, + "sys_cpu" : 43.308266, + "ctx" : 76833, + "majf" : 0, + "minf" : 44, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839621, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994818, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.438455, + "50" : 99.540851, + "100" : 0.012934, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 616305, + "read_sectors" : 0, + "write_sectors" : 156856312, + "read_merges" : 0, + "write_merges" : 5995, + "read_ticks" : 0, + "write_ticks" : 14722252, + "in_queue" : 14722252, + "util" : 98.744155 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 617098, + "read_sectors" : 0, + "write_sectors" : 156602376, + "read_merges" : 0, + "write_merges" : 5982, + "read_ticks" : 0, + "write_ticks" : 14770443, + "in_queue" : 14770443, + "util" : 98.836587 + }, + { + "name" : "nvme3n1", + "read_ios" : 0, + "write_ios" : 613035, + "read_sectors" : 0, + "write_sectors" : 155872000, + "read_merges" : 0, + "write_merges" : 5364, + "read_ticks" : 0, + "write_ticks" : 14735806, + "in_queue" : 14735807, + "util" : 98.876329 + }, + { + "name" : "nvme4n1", + "read_ios" : 0, + "write_ios" : 607066, + "read_sectors" : 0, + "write_sectors" : 154354688, + "read_merges" : 0, + "write_merges" : 6493, + "read_ticks" : 0, + "write_ticks" : 14738711, + "in_queue" : 14738711, + "util" : 99.055213 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_3.json new file mode 100644 index 0000000..fe6a3ea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w4_3.json @@ -0,0 +1,316 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771312, + "timestamp_ms" : 1793771312476, + "time" : "Wed Nov 4 05:48:32 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793771297377, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 324395859968, + "io_kbytes" : 316792832, + "bw_bytes" : 21587533104, + "bw" : 21081575, + "iops" : 5146.868969, + "runtime" : 15027, + "total_ios" : 77342, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 167980, + "max" : 1259691, + "mean" : 425261.536630, + "stddev" : 76592.251683, + "N" : 77342 + }, + "clat_ns" : { + "min" : 9485098, + "max" : 50996300, + "mean" : 24430778.364576, + "stddev" : 2172245.268736, + "N" : 77342, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22151168, + "10.000000" : 22413312, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23724032, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 25821184, + "90.000000" : 26607616, + "95.000000" : 27131904, + "99.000000" : 30277632, + "99.500000" : 34865152, + "99.900000" : 39059456, + "99.950000" : 42729472, + "99.990000" : 48496640 + } + }, + "lat_ns" : { + "min" : 10081221, + "max" : 51524290, + "mean" : 24856039.901205, + "stddev" : 2178191.743985, + "N" : 77342 + }, + "bw_min" : 18726912, + "bw_max" : 22845930, + "bw_agg" : 100.000000, + "bw_mean" : 21091881.566667, + "bw_dev" : 254904.185802, + "bw_samples" : 119, + "iops_min" : 4572, + "iops_max" : 5577, + "iops_mean" : 5149.244828, + "iops_stddev" : 62.227030, + "iops_samples" : 119 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 60097, + "usr_cpu" : 18.526715, + "sys_cpu" : 43.677721, + "ctx" : 76079, + "majf" : 0, + "minf" : 52, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839673, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994820, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.605105, + "50" : 99.383259, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 623719, + "read_sectors" : 0, + "write_sectors" : 158589184, + "read_merges" : 0, + "write_merges" : 5444, + "read_ticks" : 0, + "write_ticks" : 14972850, + "in_queue" : 14972850, + "util" : 98.731515 + }, + { + "name" : "nvme2n1", + "read_ios" : 0, + "write_ios" : 624506, + "read_sectors" : 0, + "write_sectors" : 158789608, + "read_merges" : 0, + "write_merges" : 4238, + "read_ticks" : 0, + "write_ticks" : 14988497, + "in_queue" : 14988497, + "util" : 98.829024 + }, + { + "name" : "nvme3n1", + "read_ios" : 0, + "write_ios" : 610736, + "read_sectors" : 0, + "write_sectors" : 155589120, + "read_merges" : 0, + "write_merges" : 4757, + "read_ticks" : 0, + "write_ticks" : 14696806, + "in_queue" : 14696807, + "util" : 98.842500 + }, + { + "name" : "nvme4n1", + "read_ios" : 0, + "write_ios" : 620587, + "read_sectors" : 0, + "write_sectors" : 157943808, + "read_merges" : 0, + "write_merges" : 5419, + "read_ticks" : 0, + "write_ticks" : 14954968, + "in_queue" : 14954968, + "util" : 99.050570 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme1n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme1n1.json new file mode 100644 index 0000000..7c1d9ec --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme1n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793770972, + "timestamp_ms" : 1793770972668, + "time" : "Wed Nov 4 05:42:52 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme1n1", + "groupid" : 0, + "job_start" : 1793770957597, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme1n1", + "filename" : "/dev/nvme1n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79020687360, + "io_kbytes" : 77168640, + "bw_bytes" : 5259980520, + "bw" : 5136699, + "iops" : 1254.077082, + "runtime" : 15023, + "total_ios" : 18840, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 239918, + "max" : 1328984, + "mean" : 462859.952813, + "stddev" : 127893.756030, + "N" : 18840 + }, + "clat_ns" : { + "min" : 11170760, + "max" : 44602772, + "mean" : 25041583.810775, + "stddev" : 1918014.969620, + "N" : 18840, + "percentile" : { + "1.000000" : 22151168, + "5.000000" : 22937600, + "10.000000" : 22937600, + "20.000000" : 23199744, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 25034752, + "60.000000" : 25821184, + "70.000000" : 26083328, + "80.000000" : 26607616, + "90.000000" : 27131904, + "95.000000" : 27656192, + "99.000000" : 28704768, + "99.500000" : 28966912, + "99.900000" : 39059456, + "99.950000" : 40632320, + "99.990000" : 43778048 + } + }, + "lat_ns" : { + "min" : 11740443, + "max" : 44996004, + "mean" : 25504443.763588, + "stddev" : 1951960.345189, + "N" : 18840 + }, + "bw_min" : 4856335, + "bw_max" : 5554176, + "bw_agg" : 100.000000, + "bw_mean" : 5137912.896552, + "bw_dev" : 212845.228321, + "bw_samples" : 29, + "iops_min" : 1185, + "iops_max" : 1356, + "iops_mean" : 1254.172414, + "iops_stddev" : 52.062510, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15022, + "usr_cpu" : 14.432166, + "sys_cpu" : 38.996139, + "ctx" : 23516, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.835456, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994684, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.472399, + "50" : 99.527601, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 0, + "write_ios" : 600946, + "read_sectors" : 0, + "write_sectors" : 151913472, + "read_merges" : 0, + "write_merges" : 581, + "read_ticks" : 0, + "write_ticks" : 14914983, + "in_queue" : 14914983, + "util" : 99.069861 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme2n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme2n1.json new file mode 100644 index 0000000..6e8964d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme2n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771003, + "timestamp_ms" : 1793771003505, + "time" : "Wed Nov 4 05:43:23 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme2n1", + "groupid" : 0, + "job_start" : 1793770988445, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme2n1", + "filename" : "/dev/nvme2n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80358670336, + "io_kbytes" : 78475264, + "bw_bytes" : 5349042823, + "bw" : 5223674, + "iops" : 1275.311190, + "runtime" : 15023, + "total_ios" : 19159, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 228696, + "max" : 1517952, + "mean" : 574584.536928, + "stddev" : 145449.536914, + "N" : 19159 + }, + "clat_ns" : { + "min" : 9629140, + "max" : 43584515, + "mean" : 24505375.383840, + "stddev" : 2037612.867781, + "N" : 19159, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22151168, + "10.000000" : 22151168, + "20.000000" : 22675456, + "30.000000" : 22937600, + "40.000000" : 23724032, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 26083328, + "90.000000" : 26869760, + "95.000000" : 27394048, + "99.000000" : 29491200, + "99.500000" : 29491200, + "99.900000" : 36438016, + "99.950000" : 40108032, + "99.990000" : 43778048 + } + }, + "lat_ns" : { + "min" : 10003189, + "max" : 44051367, + "mean" : 25079959.920768, + "stddev" : 2077084.186975, + "N" : 19159 + }, + "bw_min" : 4718592, + "bw_max" : 5698427, + "bw_agg" : 99.962543, + "bw_mean" : 5221718.448276, + "bw_dev" : 245621.514109, + "bw_samples" : 29, + "iops_min" : 1152, + "iops_max" : 1391, + "iops_mean" : 1274.689655, + "iops_stddev" : 59.963145, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15022, + "usr_cpu" : 14.705099, + "sys_cpu" : 35.507922, + "ctx" : 38260, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838196, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994772, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.490631, + "50" : 99.504149, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme2n1", + "read_ios" : 13, + "write_ios" : 615830, + "read_sectors" : 1192, + "write_sectors" : 154630656, + "read_merges" : 0, + "write_merges" : 1770, + "read_ticks" : 1, + "write_ticks" : 15018026, + "in_queue" : 15018026, + "util" : 99.070794 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme3n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme3n1.json new file mode 100644 index 0000000..b615dc6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme3n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771034, + "timestamp_ms" : 1793771034325, + "time" : "Wed Nov 4 05:43:54 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme3n1", + "groupid" : 0, + "job_start" : 1793771019246, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme3n1", + "filename" : "/dev/nvme3n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 78920024064, + "io_kbytes" : 77070336, + "bw_bytes" : 5251182651, + "bw" : 5128108, + "iops" : 1251.979506, + "runtime" : 15029, + "total_ios" : 18816, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 244485, + "max" : 1490780, + "mean" : 633785.335831, + "stddev" : 152074.137211, + "N" : 18816 + }, + "clat_ns" : { + "min" : 9783040, + "max" : 55516455, + "mean" : 24915047.852785, + "stddev" : 3080973.733389, + "N" : 18816, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22151168, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22675456, + "40.000000" : 23461888, + "50.000000" : 24510464, + "60.000000" : 25296896, + "70.000000" : 25821184, + "80.000000" : 26869760, + "90.000000" : 29491200, + "95.000000" : 30015488, + "99.000000" : 38535168, + "99.500000" : 40632320, + "99.900000" : 41156608, + "99.950000" : 47448064, + "99.990000" : 54788096 + } + }, + "lat_ns" : { + "min" : 10072866, + "max" : 56258089, + "mean" : 25548833.188616, + "stddev" : 3153490.662660, + "N" : 18816 + }, + "bw_min" : 4210688, + "bw_max" : 5698427, + "bw_agg" : 99.979289, + "bw_mean" : 5127046.766667, + "bw_dev" : 401263.140917, + "bw_samples" : 30, + "iops_min" : 1028, + "iops_max" : 1391, + "iops_mean" : 1251.633333, + "iops_stddev" : 97.931532, + "iops_samples" : 30 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15028, + "usr_cpu" : 14.299973, + "sys_cpu" : 35.294118, + "ctx" : 43304, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.835247, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994677, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.350765, + "50" : 99.606718, + "100" : 0.037202, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme3n1", + "read_ios" : 49, + "write_ios" : 607868, + "read_sectors" : 2120, + "write_sectors" : 152341248, + "read_merges" : 0, + "write_merges" : 1163, + "read_ticks" : 3, + "write_ticks" : 15041205, + "in_queue" : 15041208, + "util" : 99.097955 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme4n1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme4n1.json new file mode 100644 index 0000000..584fa31 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/baseline/w_nvme4n1.json @@ -0,0 +1,277 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793771065, + "timestamp_ms" : 1793771065148, + "time" : "Wed Nov 4 05:44:25 2026", + "global options" : { + "ioengine" : "libaio", + "direct" : "1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "32", + "size" : "100G", + "runtime" : "15" + }, + "jobs" : [ + { + "jobname" : "nvme4n1", + "groupid" : 0, + "job_start" : 1793771050083, + "error" : 0, + "eta" : 0, + "elapsed" : 16, + "job options" : { + "name" : "nvme4n1", + "filename" : "/dev/nvme4n1" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79297511424, + "io_kbytes" : 77438976, + "bw_bytes" : 5278407203, + "bw" : 5154694, + "iops" : 1258.470345, + "runtime" : 15023, + "total_ios" : 18906, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 246204, + "max" : 1525574, + "mean" : 632670.339839, + "stddev" : 151165.319515, + "N" : 18906 + }, + "clat_ns" : { + "min" : 9665735, + "max" : 43425263, + "mean" : 24783030.862372, + "stddev" : 2864403.300174, + "N" : 18906, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 21889024, + "10.000000" : 22151168, + "20.000000" : 22413312, + "30.000000" : 22937600, + "40.000000" : 23461888, + "50.000000" : 24510464, + "60.000000" : 25034752, + "70.000000" : 25559040, + "80.000000" : 26345472, + "90.000000" : 28966912, + "95.000000" : 29753344, + "99.000000" : 38010880, + "99.500000" : 40108032, + "99.900000" : 40108032, + "99.950000" : 40108032, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 10177913, + "max" : 44086073, + "mean" : 25415701.202211, + "stddev" : 2934489.830254, + "N" : 18906 + }, + "bw_min" : 4194107, + "bw_max" : 5709824, + "bw_agg" : 100.000000, + "bw_mean" : 5157795.551724, + "bw_dev" : 359393.153069, + "bw_samples" : 29, + "iops_min" : 1023, + "iops_max" : 1394, + "iops_mean" : 1259.034483, + "iops_stddev" : 87.903958, + "iops_samples" : 29 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 15022, + "usr_cpu" : 14.718413, + "sys_cpu" : 35.953934, + "ctx" : 42714, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.836031, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994702, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.010000, + "20" : 0.407278, + "50" : 99.587433, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme4n1", + "read_ios" : 0, + "write_ios" : 608658, + "read_sectors" : 0, + "write_sectors" : 152538624, + "read_merges" : 0, + "write_merges" : 583, + "read_ticks" : 0, + "write_ticks" : 15012349, + "in_queue" : 15012349, + "util" : 99.063044 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.cpu new file mode 100644 index 0000000..1e195ec --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 20.675983428955078, "user_s": 93.34247, "sys_s": 45.653554, "max_rss_kb": 15056244} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.json new file mode 100644 index 0000000..759e321 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru14-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 443.49, + "duration_min_ms": 434.52, + "duration_max_ms": 451.6, + "duration_p50_ms": 441.27, + "duration_p99_ms": 451.6, + "duration_std_ms": 5.38, + "throughput_avg_mbps": 16164.78, + "throughput_min_mbps": 15872.43, + "throughput_max_mbps": 16496.54, + "ops_per_sec_avg": 1154.63, + "latency_per_key_ms": 0.866 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.86, + "duration_min_ms": 10.02, + "duration_max_ms": 12.06, + "duration_p50_ms": 10.73, + "duration_p99_ms": 12.06, + "duration_std_ms": 0.5, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47214.96, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 347.41, + "duration_min_ms": 335.92, + "duration_max_ms": 362.41, + "duration_p50_ms": 346.55, + "duration_p99_ms": 362.41, + "duration_std_ms": 7.99, + "throughput_avg_mbps": 20642.58, + "throughput_min_mbps": 19778.81, + "throughput_max_mbps": 21338.49, + "ops_per_sec_avg": 1474.47, + "latency_per_key_ms": 0.679 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.cpu new file mode 100644 index 0000000..d7e414d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 21.15784788131714, "user_s": 103.912276, "sys_s": 50.652967, "max_rss_kb": 17145488} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.json new file mode 100644 index 0000000..c5a7d04 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/diag/ru16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 447.75, + "duration_min_ms": 431.18, + "duration_max_ms": 458.09, + "duration_p50_ms": 448.05, + "duration_p99_ms": 458.09, + "duration_std_ms": 8.31, + "throughput_avg_mbps": 18301.86, + "throughput_min_mbps": 17882.93, + "throughput_max_mbps": 18998.96, + "ops_per_sec_avg": 1143.87, + "latency_per_key_ms": 0.875 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.6, + "duration_min_ms": 10.41, + "duration_max_ms": 10.96, + "duration_p50_ms": 10.57, + "duration_p99_ms": 10.96, + "duration_std_ms": 0.15, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48289.08, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 349.97, + "duration_min_ms": 339.83, + "duration_max_ms": 370.67, + "duration_p50_ms": 346.41, + "duration_p99_ms": 370.67, + "duration_std_ms": 8.61, + "throughput_avg_mbps": 23420.56, + "throughput_min_mbps": 22100.54, + "throughput_max_mbps": 24106.18, + "ops_per_sec_avg": 1463.79, + "latency_per_key_ms": 0.684 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure/results.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure/results.jsonl new file mode 100644 index 0000000..85f9029 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure/results.jsonl @@ -0,0 +1,14 @@ +{"test": "kill9_during_load_meta_False", "passed": true, "utc": "07:55:49", "stored": 512, "during": {"ok": 696, "miss": 3776, "wrong": 0, "verified": 696, "batches_failed": 472, "hang": false, "seconds": 3.12, "mb_s": 3270, "batch_ms_p50": 17.4, "batch_ms_p99": 73.4, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000000b8": 5, "load missed for m@00000000@0@000000c0": 5, "load missed for m@00000000@0@000000cc": 1, "load missed for m@00000000@0@000000d0": 3}}, "after_same_connector": {"ok": 0, "miss": 512, "wrong": 0, "verified": 0, "batches_failed": 64, "hang": false, "seconds": 0.27, "mb_s": 0, "batch_ms_p50": 17.0, "batch_ms_p99": 30.0, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000002": 1, "load missed for m@00000000@0@0000000d": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001b": 1}}, "after_new_connector": {"ok": 0, "miss": 512, "wrong": 0, "verified": 0, "batches_failed": 64, "hang": false, "seconds": 0.27, "mb_s": 0, "batch_ms_p50": 17.0, "batch_ms_p99": 29.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000a": 1, "load missed for m@00000000@0@00000014": 1, "load missed for m@00000000@0@00000019": 1}}, "new_data_store": {"ok": 32, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 8, "hang": false, "seconds": 0.03, "mb_s": 17561, "batch_ms_p50": 19.8, "batch_ms_p99": 23.9, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00002710: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002721: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000272f: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000271a: Broken pipe (os error 32)": 1}, "first_try_failed": 32, "retry_ok": 32}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9262, "batch_ms_p50": 32.3, "batch_ms_p99": 42.0, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 3776, "store_failures": 32, "direct_read_bytes": 11156848640, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_load_meta_True", "passed": true, "utc": "07:56:20", "stored": 512, "during": {"ok": 776, "miss": 3768, "wrong": 0, "verified": 776, "batches_failed": 471, "hang": false, "seconds": 3.14, "mb_s": 3631, "batch_ms_p50": 17.8, "batch_ms_p99": 69.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000010b": 1, "load missed for m@00000000@0@00000110": 4, "load missed for m@00000000@0@00000118": 5, "load missed for m@00000000@0@00000124": 2}}, "after_same_connector": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 9598, "batch_ms_p50": 55.7, "batch_ms_p99": 72.7, "wrong_ids": [], "errors": {}}, "after_new_connector": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.8, "mb_s": 9401, "batch_ms_p50": 54.8, "batch_ms_p99": 83.3, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 32, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 7, "hang": false, "seconds": 0.03, "mb_s": 14042, "batch_ms_p50": 25.8, "batch_ms_p99": 30.2, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00002712: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002731: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002728: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000271b: Broken pipe (os error 32)": 1}, "first_try_failed": 32, "retry_ok": 32}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 9967, "batch_ms_p50": 31.5, "batch_ms_p99": 40.8, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 3768, "store_failures": 32, "direct_read_bytes": 19847446528, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_False", "passed": true, "utc": "07:56:47", "during": {"ok": 1439, "miss": 48753, "wrong": 0, "verified": 0, "batches_failed": 6095, "hang": false, "seconds": 3.13, "mb_s": 6749, "batch_ms_p50": 1.4, "batch_ms_p99": 47.6, "wrong_ids": [], "errors": {"store failed for m@00000000@0@0000059d: Connection reset by peer (os error 104)": 1, "store failed for m@00000000@0@000005c0: Connection refused (os error 111)": 8, "store failed for m@00000000@0@000005c8: Connection refused (os error 111)": 7, "store failed for m@00000000@0@000005d0: Connection refused (os error 111)": 9}}, "after": {"ok": 0, "miss": 4096, "wrong": 0, "verified": 0, "batches_failed": 512, "hang": false, "seconds": 2.18, "mb_s": 0, "batch_ms_p50": 17.0, "batch_ms_p99": 30.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@00000008": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001f": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.06, "mb_s": 16903, "batch_ms_p50": 45.8, "batch_ms_p99": 52.4, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 10000, "batch_ms_p50": 29.9, "batch_ms_p99": 38.5, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 48753, "direct_read_bytes": 939524096, "direct_write_bytes": 22533898240, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_True", "passed": true, "utc": "07:57:16", "during": {"ok": 1437, "miss": 47019, "wrong": 0, "verified": 0, "batches_failed": 5879, "hang": false, "seconds": 3.13, "mb_s": 6749, "batch_ms_p50": 1.4, "batch_ms_p99": 47.5, "wrong_ids": [], "errors": {"store failed for m@00000000@0@000005c0: Connection refused (os error 111)": 10, "store failed for m@00000000@0@000005c8: Connection refused (os error 111)": 11, "store failed for m@00000000@0@00000596: daemon closed the connection": 1, "store failed for m@00000000@0@0000059e: Connection reset by peer (os error 104)": 1}}, "after": {"ok": 1408, "miss": 2688, "wrong": 0, "verified": 1408, "batches_failed": 337, "hang": false, "seconds": 3.52, "mb_s": 5872, "batch_ms_p50": 21.2, "batch_ms_p99": 69.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000577": 1, "load missed for m@00000000@0@00000587": 1, "load missed for m@00000000@0@0000058b": 1, "load missed for m@00000000@0@00000591": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 18104, "batch_ms_p50": 42.6, "batch_ms_p99": 49.1, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9459, "batch_ms_p50": 31.5, "batch_ms_p99": 42.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 47019, "direct_read_bytes": 21609054208, "direct_write_bytes": 22489858048, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_clean_wait0", "passed": true, "utc": "07:57:41", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.77, "mb_s": 9809, "batch_ms_p50": 52.0, "batch_ms_p99": 68.2, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 32, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 8, "hang": false, "seconds": 0.03, "mb_s": 16128, "batch_ms_p50": 21.9, "batch_ms_p99": 25.8, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00002717: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002718: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002720: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002728: Broken pipe (os error 32)": 1}, "first_try_failed": 32, "retry_ok": 32}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 10341, "batch_ms_p50": 27.6, "batch_ms_p99": 36.2, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 10137, "batch_ms_p50": 49.0, "batch_ms_p99": 69.3, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait0", "passed": true, "utc": "07:58:06", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 9532, "batch_ms_p50": 53.3, "batch_ms_p99": 86.7, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 32, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 6, "hang": false, "seconds": 0.03, "mb_s": 17074, "batch_ms_p50": 16.7, "batch_ms_p99": 24.6, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00002710: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002719: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000272a: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002730: Broken pipe (os error 32)": 1}, "first_try_failed": 32, "retry_ok": 32}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9233, "batch_ms_p50": 30.5, "batch_ms_p99": 43.5, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.84, "mb_s": 8911, "batch_ms_p50": 58.1, "batch_ms_p99": 87.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait3", "passed": true, "utc": "07:58:34", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 9659, "batch_ms_p50": 53.2, "batch_ms_p99": 76.8, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 32, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 8, "hang": false, "seconds": 0.03, "mb_s": 14554, "batch_ms_p50": 25.1, "batch_ms_p99": 29.1, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00002710: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000271b: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002739: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00002729: Broken pipe (os error 32)": 1}, "first_try_failed": 32, "retry_ok": 32}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 8965, "batch_ms_p50": 34.8, "batch_ms_p99": 45.5, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 9673, "batch_ms_p50": 55.5, "batch_ms_p99": 73.8, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap0", "passed": false, "utc": "07:59:06", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.53, "mb_s": 7082, "batch_ms_p50": 25.8, "batch_ms_p99": 70.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000015": 1, "load missed for m@00000000@0@0000001b": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.39, "mb_s": 9616, "batch_ms_p50": 48.6, "batch_ms_p99": 82.1, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 8, "hang": false, "seconds": 0.35, "mb_s": 20258, "batch_ms_p50": 42.6, "batch_ms_p99": 59.8, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00007531: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007550: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007549: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000755e: Broken pipe (os error 32)": 1}}, "load_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 480, "batches_failed": 8, "hang": false, "seconds": 0.78, "mb_s": 9036, "batch_ms_p50": 55.4, "batch_ms_p99": 77.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00007533": 1, "load missed for m@00000000@0@00007538": 1, "load missed for m@00000000@0@00007543": 1, "load missed for m@00000000@0@00007549": 1}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.55, "mb_s": 6836, "batch_ms_p50": 26.1, "batch_ms_p99": 78.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 1, "load missed for m@00000000@0@00000008": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@0000001e": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.4, "mb_s": 9494, "batch_ms_p50": 50.5, "batch_ms_p99": 78.8, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 22078816256, "direct_write_bytes": 18320719872, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap3", "passed": false, "utc": "07:59:41", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.5, "mb_s": 7476, "batch_ms_p50": 25.5, "batch_ms_p99": 72.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000d": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@00000018": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.37, "mb_s": 10161, "batch_ms_p50": 44.9, "batch_ms_p99": 70.8, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 7, "hang": false, "seconds": 0.37, "mb_s": 19166, "batch_ms_p50": 45.5, "batch_ms_p99": 60.9, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00007530: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007543: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007548: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007557: Broken pipe (os error 32)": 1}}, "load_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 480, "batches_failed": 7, "hang": false, "seconds": 0.8, "mb_s": 8765, "batch_ms_p50": 56.6, "batch_ms_p99": 79.0, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00007535": 1, "load missed for m@00000000@0@00007538": 1, "load missed for m@00000000@0@00007546": 1, "load missed for m@00000000@0@0000754f": 1}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.55, "mb_s": 6783, "batch_ms_p50": 25.7, "batch_ms_p99": 75.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000010": 1, "load missed for m@00000000@0@0000001b": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.41, "mb_s": 9092, "batch_ms_p50": 55.1, "batch_ms_p99": 76.1, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 22078816256, "direct_write_bytes": 18320719872, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace1_gap0", "passed": false, "utc": "08:00:14", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.55, "mb_s": 6775, "batch_ms_p50": 25.6, "batch_ms_p99": 84.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 1, "load missed for m@00000000@0@0000000d": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001f": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.41, "mb_s": 9206, "batch_ms_p50": 50.5, "batch_ms_p99": 74.4, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 0, "batches_failed": 8, "hang": false, "seconds": 0.37, "mb_s": 19271, "batch_ms_p50": 44.5, "batch_ms_p99": 55.4, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00007530: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000754f: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@00007540: Broken pipe (os error 32)": 1, "store failed for m@00000000@0@0000755f: Broken pipe (os error 32)": 1}}, "load_d": {"ok": 480, "miss": 32, "wrong": 0, "verified": 480, "batches_failed": 8, "hang": false, "seconds": 0.77, "mb_s": 9114, "batch_ms_p50": 52.2, "batch_ms_p99": 82.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00007536": 1, "load missed for m@00000000@0@00007538": 1, "load missed for m@00000000@0@00007546": 1, "load missed for m@00000000@0@00007549": 1}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.5, "mb_s": 7566, "batch_ms_p50": 25.3, "batch_ms_p99": 67.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@00000019": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.37, "mb_s": 10173, "batch_ms_p50": 37.2, "batch_ms_p99": 86.7, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 32, "direct_read_bytes": 22078816256, "direct_write_bytes": 18320719872, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "corruption", "passed": true, "utc": "08:00:37", "one_block": {"ok": 511, "miss": 1, "wrong": 0, "verified": 511, "batches_failed": 1, "hang": false, "seconds": 0.74, "mb_s": 10201, "batch_ms_p50": 51.0, "batch_ms_p99": 72.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000010": 1}}, "checksum_failures_one": 1, "one_gib": {"ok": 218, "miss": 294, "wrong": 0, "verified": 218, "batches_failed": 37, "hang": false, "seconds": 0.57, "mb_s": 5643, "batch_ms_p50": 34.5, "batch_ms_p99": 75.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000e": 1, "load missed for m@00000000@0@00000010": 1, "load missed for m@00000000@0@0000001e": 1}}, "checksum_failures_many": 294} +{"test": "corruption_repaired_by_new_store", "passed": true, "utc": "08:00:37", "store_again": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.23, "mb_s": 33269, "batch_ms_p50": 40.8, "batch_ms_p99": 57.3, "wrong_ids": [], "errors": {}}, "load_after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.81, "mb_s": 9336, "batch_ms_p50": 56.1, "batch_ms_p99": 79.9, "wrong_ids": [], "errors": {}}} +{"test": "capacity_cap_20g", "passed": true, "utc": "07:47:43", "store_rounds": [{"ok": 5747, "miss": 13, "wrong": 0, "verified": 0, "batches_failed": 5, "hang": false, "seconds": 4.3, "mb_s": 19638, "batch_ms_p50": 46.0, "batch_ms_p99": 59.5, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00000e11: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00000e11.kv' was not s": 1, "store failed for m@00000000@0@00000e19: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00000e19.kv' was not s": 1, "store failed for m@00000000@0@0000116c: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/0000116c.kv' was not s": 1, "store failed for m@00000000@0@00001170: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00001170.kv' was not s": 1}}, {"ok": 5735, "miss": 25, "wrong": 0, "verified": 0, "batches_failed": 11, "hang": false, "seconds": 5.03, "mb_s": 16727, "batch_ms_p50": 49.4, "batch_ms_p99": 88.3, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00000024: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00000024.kv' was not s": 1, "store failed for m@00000000@0@00000385: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00000385.kv' was not s": 1, "store failed for m@00000000@0@00000389: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/00000389.kv' was not s": 1, "store failed for m@00000000@0@000006e7: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/000006e7.kv' was not s": 1}}], "load_during": {"ok": 815, "miss": 15361, "wrong": 0, "verified": 815, "batches_failed": 1977, "hang": false, "seconds": 10.29, "mb_s": 1163, "batch_ms_p50": 17.8, "batch_ms_p99": 95.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000003": 1, "load missed for m@00000000@0@0000000a": 2, "load missed for m@00000000@0@00000017": 2, "load missed for m@00000000@0@0000002a": 1}}, "load_quiet": {"ok": 1462, "miss": 4298, "wrong": 0, "verified": 1462, "batches_failed": 560, "hang": false, "seconds": 4.59, "mb_s": 4677, "batch_ms_p50": 21.2, "batch_ms_p99": 70.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000003": 1, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000016": 1, "load missed for m@00000000@0@0000001d": 1}}, "store_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.21, "mb_s": 18328, "batch_ms_p50": 45.0, "batch_ms_p99": 58.0, "wrong_ids": [], "errors": {}}, "load_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.38, "mb_s": 9859, "batch_ms_p50": 47.6, "batch_ms_p99": 75.7, "wrong_ids": [], "errors": {}}, "evict_log_lines": "10353", "log_errors": "", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 38, "direct_read_bytes": 0, "direct_write_bytes": 172872433664, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "device_full_loop_20g", "passed": true, "utc": "07:49:25", "store_rounds": [{"ok": 5760, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 25.74, "mb_s": 3285, "batch_ms_p50": 279.1, "batch_ms_p99": 596.0, "wrong_ids": [], "errors": {}}, {"ok": 5760, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 24.28, "mb_s": 3483, "batch_ms_p50": 266.5, "batch_ms_p99": 509.2, "wrong_ids": [], "errors": {}}], "load_during": {"ok": 10945, "miss": 16959, "wrong": 0, "verified": 10945, "batches_failed": 2151, "hang": false, "seconds": 51.0, "mb_s": 3150, "batch_ms_p50": 26.3, "batch_ms_p99": 406.6, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 2, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@00000018": 1}}, "load_quiet": {"ok": 1462, "miss": 4298, "wrong": 0, "verified": 1462, "batches_failed": 538, "hang": false, "seconds": 5.21, "mb_s": 4122, "batch_ms_p50": 21.2, "batch_ms_p99": 120.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000005": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@0000001a": 1}}, "store_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.7, "mb_s": 5343, "batch_ms_p50": 162.5, "batch_ms_p99": 245.1, "wrong_ids": [], "errors": {}}, "load_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.52, "mb_s": 7235, "batch_ms_p50": 103.6, "batch_ms_p99": 123.3, "wrong_ids": [], "errors": {}}, "evict_log_lines": "10315", "log_errors": "", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 172872433664, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure_final/results.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure_final/results.jsonl new file mode 100644 index 0000000..61d153f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/failure_final/results.jsonl @@ -0,0 +1,12 @@ +{"test": "kill9_during_load_meta_False", "passed": true, "utc": "08:12:19", "stored": 512, "during": {"ok": 776, "miss": 3808, "wrong": 0, "verified": 776, "batches_failed": 476, "hang": false, "seconds": 3.12, "mb_s": 3655, "batch_ms_p50": 21.1, "batch_ms_p99": 64.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000010b": 2, "load missed for m@00000000@0@00000112": 2, "load missed for m@00000000@0@00000119": 3, "load missed for m@00000000@0@00000120": 3}}, "after_same_connector": {"ok": 0, "miss": 512, "wrong": 0, "verified": 0, "batches_failed": 64, "hang": false, "seconds": 0.27, "mb_s": 0, "batch_ms_p50": 16.9, "batch_ms_p99": 29.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000002": 1, "load missed for m@00000000@0@00000008": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@00000018": 1}}, "after_new_connector": {"ok": 0, "miss": 512, "wrong": 0, "verified": 0, "batches_failed": 64, "hang": false, "seconds": 0.27, "mb_s": 0, "batch_ms_p50": 16.9, "batch_ms_p99": 29.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000a": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001b": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 17947, "batch_ms_p50": 41.6, "batch_ms_p99": 49.3, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 10073, "batch_ms_p50": 29.9, "batch_ms_p99": 39.4, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 3808, "store_failures": 0, "direct_read_bytes": 12331253760, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_load_meta_True", "passed": true, "utc": "08:12:50", "stored": 512, "during": {"ok": 760, "miss": 3776, "wrong": 0, "verified": 760, "batches_failed": 472, "hang": false, "seconds": 3.11, "mb_s": 3582, "batch_ms_p50": 17.3, "batch_ms_p99": 68.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000000fb": 2, "load missed for m@00000000@0@00000102": 2, "load missed for m@00000000@0@0000010d": 1, "load missed for m@00000000@0@00000113": 2}}, "after_same_connector": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.75, "mb_s": 9962, "batch_ms_p50": 52.3, "batch_ms_p99": 75.9, "wrong_ids": [], "errors": {}}, "after_new_connector": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 9461, "batch_ms_p50": 54.9, "batch_ms_p99": 74.4, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 18906, "batch_ms_p50": 37.3, "batch_ms_p99": 46.4, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.11, "mb_s": 8802, "batch_ms_p50": 35.7, "batch_ms_p99": 55.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 3776, "store_failures": 0, "direct_read_bytes": 19612565504, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_False", "passed": true, "utc": "08:13:17", "during": {"ok": 1435, "miss": 48309, "wrong": 0, "verified": 0, "batches_failed": 6039, "hang": false, "seconds": 3.13, "mb_s": 6740, "batch_ms_p50": 1.4, "batch_ms_p99": 47.6, "wrong_ids": [], "errors": {"store failed for m@00000000@0@000005c1: Connection refused (os error 111)": 2, "store failed for m@00000000@0@000005c8: Connection refused (os error 111)": 10, "store failed for m@00000000@0@000005d0: Connection refused (os error 111)": 7, "store failed for m@00000000@0@0000059f: Connection reset by peer (os error 104)": 1}}, "after": {"ok": 0, "miss": 4096, "wrong": 0, "verified": 0, "batches_failed": 512, "hang": false, "seconds": 2.18, "mb_s": 0, "batch_ms_p50": 17.1, "batch_ms_p99": 29.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 1, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000015": 1, "load missed for m@00000000@0@0000001c": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 18294, "batch_ms_p50": 43.3, "batch_ms_p99": 48.3, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9345, "batch_ms_p50": 29.8, "batch_ms_p99": 38.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 48309, "direct_read_bytes": 939524096, "direct_write_bytes": 22460497920, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_True", "passed": true, "utc": "08:13:46", "during": {"ok": 1436, "miss": 44972, "wrong": 0, "verified": 0, "batches_failed": 5622, "hang": false, "seconds": 3.13, "mb_s": 6745, "batch_ms_p50": 1.5, "batch_ms_p99": 48.2, "wrong_ids": [], "errors": {"store failed for m@00000000@0@000005c0: Connection refused (os error 111)": 10, "store failed for m@00000000@0@000005c8: Connection refused (os error 111)": 8, "store failed for m@00000000@0@000005d2: Connection refused (os error 111)": 1, "store failed for m@00000000@0@0000059f: Connection reset by peer (os error 104)": 1}}, "after": {"ok": 1402, "miss": 2694, "wrong": 0, "verified": 1402, "batches_failed": 338, "hang": false, "seconds": 3.57, "mb_s": 5771, "batch_ms_p50": 21.6, "batch_ms_p99": 69.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000577": 1, "load missed for m@00000000@0@00000582": 1, "load missed for m@00000000@0@0000058b": 1, "load missed for m@00000000@0@0000057c": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 18670, "batch_ms_p50": 44.8, "batch_ms_p99": 47.2, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 9921, "batch_ms_p50": 28.5, "batch_ms_p99": 37.1, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 44972, "direct_read_bytes": 21520973824, "direct_write_bytes": 22475177984, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_clean_wait0", "passed": true, "utc": "08:14:10", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.72, "mb_s": 10440, "batch_ms_p50": 50.3, "batch_ms_p99": 68.3, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 17196, "batch_ms_p50": 42.9, "batch_ms_p99": 51.9, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.09, "mb_s": 10131, "batch_ms_p50": 29.7, "batch_ms_p99": 38.4, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.82, "mb_s": 9155, "batch_ms_p50": 56.2, "batch_ms_p99": 80.2, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait0", "passed": true, "utc": "08:14:34", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.72, "mb_s": 10473, "batch_ms_p50": 50.2, "batch_ms_p99": 71.5, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 19592, "batch_ms_p50": 37.0, "batch_ms_p99": 44.7, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9006, "batch_ms_p50": 33.7, "batch_ms_p99": 43.7, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.8, "mb_s": 9379, "batch_ms_p50": 56.7, "batch_ms_p99": 76.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait3", "passed": true, "utc": "08:15:02", "stored": 512, "after": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.76, "mb_s": 9891, "batch_ms_p50": 51.6, "batch_ms_p99": 74.8, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.05, "mb_s": 19333, "batch_ms_p50": 39.0, "batch_ms_p99": 45.4, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.1, "mb_s": 9103, "batch_ms_p50": 34.2, "batch_ms_p99": 51.4, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 9619, "batch_ms_p50": 54.2, "batch_ms_p99": 77.7, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 15971909632, "direct_write_bytes": 8455716864, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap0", "passed": true, "utc": "08:15:34", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.51, "mb_s": 7384, "batch_ms_p50": 25.5, "batch_ms_p99": 68.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000005": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000010": 1, "load missed for m@00000000@0@0000001b": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.35, "mb_s": 10622, "batch_ms_p50": 46.9, "batch_ms_p99": 63.4, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.39, "mb_s": 19421, "batch_ms_p50": 45.9, "batch_ms_p99": 57.9, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.76, "mb_s": 9925, "batch_ms_p50": 52.1, "batch_ms_p99": 74.0, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.52, "mb_s": 7178, "batch_ms_p50": 25.4, "batch_ms_p99": 68.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000004": 1, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000014": 1, "load missed for m@00000000@0@0000001b": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.4, "mb_s": 9322, "batch_ms_p50": 48.0, "batch_ms_p99": 81.9, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 22548578304, "direct_write_bytes": 18790481920, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap3", "passed": true, "utc": "08:16:09", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.54, "mb_s": 6977, "batch_ms_p50": 25.5, "batch_ms_p99": 71.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 1, "load missed for m@00000000@0@0000000c": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@00000018": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.41, "mb_s": 9230, "batch_ms_p50": 53.9, "batch_ms_p99": 75.0, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.39, "mb_s": 19407, "batch_ms_p50": 47.1, "batch_ms_p99": 58.3, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.81, "mb_s": 9316, "batch_ms_p50": 57.0, "batch_ms_p99": 84.0, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.56, "mb_s": 6751, "batch_ms_p50": 25.6, "batch_ms_p99": 77.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000004": 1, "load missed for m@00000000@0@0000000e": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@00000019": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.4, "mb_s": 9436, "batch_ms_p50": 51.8, "batch_ms_p99": 73.5, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 22548578304, "direct_write_bytes": 18790481920, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace1_gap0", "passed": true, "utc": "08:16:42", "stored_b": 256, "load_a": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.54, "mb_s": 7013, "batch_ms_p50": 29.4, "batch_ms_p99": 71.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000011": 1, "load missed for m@00000000@0@0000001f": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.39, "mb_s": 9549, "batch_ms_p50": 47.1, "batch_ms_p99": 76.7, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.38, "mb_s": 19963, "batch_ms_p50": 44.6, "batch_ms_p99": 60.3, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.8, "mb_s": 9451, "batch_ms_p50": 56.6, "batch_ms_p99": 73.6, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 256, "miss": 256, "wrong": 0, "verified": 256, "batches_failed": 32, "hang": false, "seconds": 0.6, "mb_s": 6272, "batch_ms_p50": 25.6, "batch_ms_p99": 91.4, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000d": 1, "load missed for m@00000000@0@00000010": 1, "load missed for m@00000000@0@0000001c": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.42, "mb_s": 8970, "batch_ms_p50": 35.6, "batch_ms_p99": 90.5, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 22548578304, "direct_write_bytes": 18790481920, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "upgrade_old_to_fixed_clean", "passed": true, "utc": "08:37:37", "stored_by_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.47, "mb_s": 15965, "batch_ms_p50": 55.6, "batch_ms_p99": 79.3, "wrong_ids": [], "errors": {}}, "fixed_reads_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.76, "mb_s": 9888, "batch_ms_p50": 52.4, "batch_ms_p99": 71.4, "wrong_ids": [], "errors": {}}, "stored_by_fixed": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.37, "mb_s": 20243, "batch_ms_p50": 44.4, "batch_ms_p99": 56.5, "wrong_ids": [], "errors": {}}, "fixed_reads_new": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.77, "mb_s": 9786, "batch_ms_p50": 52.6, "batch_ms_p99": 74.6, "wrong_ids": [], "errors": {}}, "fixed_reads_old_again": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.77, "mb_s": 9771, "batch_ms_p50": 53.8, "batch_ms_p99": 70.5, "wrong_ids": [], "errors": {}}, "old_reads_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.82, "mb_s": 9191, "batch_ms_p50": 57.4, "batch_ms_p99": 76.9, "wrong_ids": [], "errors": {}}, "old_reads_fixed": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.8, "mb_s": 9401, "batch_ms_p50": 55.3, "batch_ms_p99": 75.0, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 37580963840, "direct_write_bytes": 15032385536, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "upgrade_old_to_fixed_kill", "passed": true, "utc": "08:38:16", "stored_by_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.46, "mb_s": 16179, "batch_ms_p50": 53.6, "batch_ms_p99": 77.4, "wrong_ids": [], "errors": {}}, "fixed_reads_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 9500, "batch_ms_p50": 53.8, "batch_ms_p99": 79.6, "wrong_ids": [], "errors": {}}, "stored_by_fixed": {"ok": 512, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.39, "mb_s": 19419, "batch_ms_p50": 46.3, "batch_ms_p99": 61.6, "wrong_ids": [], "errors": {}}, "fixed_reads_new": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.77, "mb_s": 9814, "batch_ms_p50": 53.1, "batch_ms_p99": 73.7, "wrong_ids": [], "errors": {}}, "fixed_reads_old_again": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.76, "mb_s": 9939, "batch_ms_p50": 52.3, "batch_ms_p99": 69.0, "wrong_ids": [], "errors": {}}, "old_reads_old": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 9470, "batch_ms_p50": 53.4, "batch_ms_p99": 85.3, "wrong_ids": [], "errors": {}}, "old_reads_fixed": {"ok": 512, "miss": 0, "wrong": 0, "verified": 512, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 9561, "batch_ms_p50": 54.5, "batch_ms_p99": 70.0, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 37580963840, "direct_write_bytes": 15032385536, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_1.json new file mode 100644 index 0000000..9e16b8f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_1.json @@ -0,0 +1,1073 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793783884, + "timestamp_ms" : 1793783884332, + "time" : "Wed Nov 4 09:18:04 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793783854257, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 203729928192, + "io_kbytes" : 198955008, + "bw_bytes" : 6786473290, + "bw" : 6627415, + "iops" : 1618.021319, + "runtime" : 30020, + "total_ios" : 48573, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 171160, + "max" : 2115427, + "mean" : 267691.617730, + "stddev" : 76045.831481, + "N" : 48573 + }, + "clat_ns" : { + "min" : 8049409, + "max" : 48707110, + "mean" : 19491086.943673, + "stddev" : 1206723.149117, + "N" : 48573, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19267584, + "50.000000" : 19529728, + "60.000000" : 19529728, + "70.000000" : 19791872, + "80.000000" : 20316160, + "90.000000" : 20840448, + "95.000000" : 21102592, + "99.000000" : 22151168, + "99.500000" : 22937600, + "99.900000" : 30015488, + "99.950000" : 32374784, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 8370788, + "max" : 50585177, + "mean" : 19758778.561402, + "stddev" : 1207852.854249, + "N" : 48573 + }, + "bw_min" : 6193152, + "bw_max" : 6676480, + "bw_agg" : 24.999492, + "bw_mean" : 6626496.483333, + "bw_dev" : 67859.016026, + "bw_samples" : 60, + "iops_min" : 1512, + "iops_max" : 1630, + "iops_mean" : 1617.733333, + "iops_stddev" : 16.568161, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30019, + "usr_cpu" : 0.429728, + "sys_cpu" : 49.445351, + "ctx" : 33080, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.936179, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997940, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.092644, + "20" : 72.663826, + "50" : 27.243530, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793783854257, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 203838980096, + "io_kbytes" : 199061504, + "bw_bytes" : 6790332126, + "bw" : 6631183, + "iops" : 1618.941337, + "runtime" : 30019, + "total_ios" : 48599, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 136980, + "max" : 1800587, + "mean" : 286166.876006, + "stddev" : 100583.783749, + "N" : 48599 + }, + "clat_ns" : { + "min" : 8069298, + "max" : 47014092, + "mean" : 19462813.331406, + "stddev" : 1179112.947270, + "N" : 48599, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19267584, + "50.000000" : 19267584, + "60.000000" : 19529728, + "70.000000" : 19791872, + "80.000000" : 20316160, + "90.000000" : 20840448, + "95.000000" : 21102592, + "99.000000" : 22151168, + "99.500000" : 22675456, + "99.900000" : 29229056, + "99.950000" : 31326208, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8325567, + "max" : 48399820, + "mean" : 19748980.207412, + "stddev" : 1175291.619880, + "N" : 48599 + }, + "bw_min" : 6234112, + "bw_max" : 6684672, + "bw_agg" : 25.012877, + "bw_mean" : 6630044.733333, + "bw_dev" : 64864.455163, + "bw_samples" : 60, + "iops_min" : 1522, + "iops_max" : 1632, + "iops_mean" : 1618.600000, + "iops_stddev" : 15.830886, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30018, + "usr_cpu" : 0.439736, + "sys_cpu" : 52.645080, + "ctx" : 31583, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.936213, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997941, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.088479, + "20" : 73.378053, + "50" : 26.533468, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793783854257, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 203616681984, + "io_kbytes" : 198844416, + "bw_bytes" : 6782926879, + "bw" : 6623952, + "iops" : 1617.175789, + "runtime" : 30019, + "total_ios" : 48546, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 160880, + "max" : 2117327, + "mean" : 282782.719936, + "stddev" : 102274.753566, + "N" : 48546 + }, + "clat_ns" : { + "min" : 8361788, + "max" : 48396390, + "mean" : 19486457.898591, + "stddev" : 1258127.731712, + "N" : 48546, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19267584, + "50.000000" : 19267584, + "60.000000" : 19529728, + "70.000000" : 19791872, + "80.000000" : 20316160, + "90.000000" : 20840448, + "95.000000" : 21102592, + "99.000000" : 22413312, + "99.500000" : 23199744, + "99.900000" : 30277632, + "99.950000" : 32374784, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8626527, + "max" : 50513717, + "mean" : 19769240.618527, + "stddev" : 1255541.045707, + "N" : 48546 + }, + "bw_min" : 6160384, + "bw_max" : 6676480, + "bw_agg" : 24.985593, + "bw_mean" : 6622812.533333, + "bw_dev" : 71392.154499, + "bw_samples" : 60, + "iops_min" : 1504, + "iops_max" : 1630, + "iops_mean" : 1616.833333, + "iops_stddev" : 17.440618, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30018, + "usr_cpu" : 0.439736, + "sys_cpu" : 51.672330, + "ctx" : 32021, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.936143, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997939, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.105055, + "20" : 72.560046, + "50" : 27.334899, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793783854257, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 203637653504, + "io_kbytes" : 198864896, + "bw_bytes" : 6783625487, + "bw" : 6624634, + "iops" : 1617.342350, + "runtime" : 30019, + "total_ios" : 48551, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163650, + "max" : 2182887, + "mean" : 266924.275175, + "stddev" : 85575.213179, + "N" : 48551 + }, + "clat_ns" : { + "min" : 8352628, + "max" : 47824780, + "mean" : 19500476.618339, + "stddev" : 1147094.050800, + "N" : 48551, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18481152, + "20.000000" : 18743296, + "30.000000" : 19005440, + "40.000000" : 19267584, + "50.000000" : 19529728, + "60.000000" : 19529728, + "70.000000" : 20054016, + "80.000000" : 20316160, + "90.000000" : 20840448, + "95.000000" : 21102592, + "99.000000" : 22151168, + "99.500000" : 22675456, + "99.900000" : 28704768, + "99.950000" : 31850496, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8659457, + "max" : 49983367, + "mean" : 19767400.893514, + "stddev" : 1147304.655891, + "N" : 48551 + }, + "bw_min" : 6209536, + "bw_max" : 6679504, + "bw_agg" : 24.988151, + "bw_mean" : 6623490.583333, + "bw_dev" : 67619.921884, + "bw_samples" : 60, + "iops_min" : 1516, + "iops_max" : 1630, + "iops_mean" : 1617.000000, + "iops_stddev" : 16.494478, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30018, + "usr_cpu" : 0.426411, + "sys_cpu" : 49.420348, + "ctx" : 33217, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.936150, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997939, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.078268, + "20" : 72.255978, + "50" : 27.665754, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1565444, + "write_ios" : 0, + "read_sectors" : 396110336, + "write_sectors" : 0, + "read_merges" : 18139, + "write_merges" : 0, + "read_ticks" : 28306144, + "write_ticks" : 0, + "in_queue" : 28306144, + "util" : 99.682974 + }, + { + "name" : "nvme2n1", + "read_ios" : 1561712, + "write_ios" : 0, + "read_sectors" : 396315904, + "write_sectors" : 0, + "read_merges" : 19674, + "write_merges" : 0, + "read_ticks" : 28158017, + "write_ticks" : 0, + "in_queue" : 28158017, + "util" : 99.709555 + }, + { + "name" : "nvme3n1", + "read_ios" : 1567596, + "write_ios" : 0, + "read_sectors" : 395892752, + "write_sectors" : 0, + "read_merges" : 24179, + "write_merges" : 0, + "read_ticks" : 28341051, + "write_ticks" : 0, + "in_queue" : 28341051, + "util" : 99.746218 + }, + { + "name" : "nvme4n1", + "read_ios" : 1563245, + "write_ios" : 0, + "read_sectors" : 395936000, + "write_sectors" : 0, + "read_merges" : 22664, + "write_merges" : 0, + "read_ticks" : 28328601, + "write_ticks" : 0, + "in_queue" : 28328601, + "util" : 99.846252 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_2.json new file mode 100644 index 0000000..25960fa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_2.json @@ -0,0 +1,1073 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784006, + "timestamp_ms" : 1793784006284, + "time" : "Wed Nov 4 09:20:06 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793783976224, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207513190400, + "io_kbytes" : 202649600, + "bw_bytes" : 6912958571, + "bw" : 6750936, + "iops" : 1648.177760, + "runtime" : 30018, + "total_ios" : 49475, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 174019, + "max" : 2101907, + "mean" : 251665.595695, + "stddev" : 60860.952028, + "N" : 49475 + }, + "clat_ns" : { + "min" : 8266367, + "max" : 47847565, + "mean" : 19146038.309672, + "stddev" : 978850.586385, + "N" : 49475, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21626880, + "99.900000" : 25296896, + "99.950000" : 29753344, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8574846, + "max" : 49949472, + "mean" : 19397703.905366, + "stddev" : 981993.418693, + "N" : 49475 + }, + "bw_min" : 6307840, + "bw_max" : 6785788, + "bw_agg" : 25.013954, + "bw_mean" : 6754158.033898, + "bw_dev" : 60030.213114, + "bw_samples" : 59, + "iops_min" : 1540, + "iops_max" : 1656, + "iops_mean" : 1648.881356, + "iops_stddev" : 14.651215, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.346470, + "sys_cpu" : 50.071626, + "ctx" : 34134, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937342, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997978, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.066700, + "20" : 86.081860, + "50" : 13.851440, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793783976224, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207462858752, + "io_kbytes" : 202600448, + "bw_bytes" : 6911281855, + "bw" : 6749298, + "iops" : 1647.778000, + "runtime" : 30018, + "total_ios" : 49463, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 164460, + "max" : 1905097, + "mean" : 251628.308776, + "stddev" : 62704.239299, + "N" : 49463 + }, + "clat_ns" : { + "min" : 7823078, + "max" : 47905575, + "mean" : 19150986.701231, + "stddev" : 1044331.659372, + "N" : 49463, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21626880, + "99.500000" : 21889024, + "99.900000" : 27131904, + "99.950000" : 31064064, + "99.990000" : 41680896 + } + }, + "lat_ns" : { + "min" : 8211938, + "max" : 49520073, + "mean" : 19402615.010008, + "stddev" : 1046186.934775, + "N" : 49463 + }, + "bw_min" : 6316032, + "bw_max" : 6791168, + "bw_agg" : 25.008298, + "bw_mean" : 6752631.000000, + "bw_dev" : 59400.121056, + "bw_samples" : 59, + "iops_min" : 1542, + "iops_max" : 1658, + "iops_mean" : 1648.508475, + "iops_stddev" : 14.496579, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.526368, + "sys_cpu" : 49.388680, + "ctx" : 34323, + "majf" : 0, + "minf" : 32778, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937327, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997977, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.099064, + "20" : 85.607424, + "50" : 14.293512, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793783976224, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207517384704, + "io_kbytes" : 202653696, + "bw_bytes" : 6913098297, + "bw" : 6751072, + "iops" : 1648.211073, + "runtime" : 30018, + "total_ios" : 49476, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 165570, + "max" : 1928457, + "mean" : 243870.687465, + "stddev" : 63626.699532, + "N" : 49476 + }, + "clat_ns" : { + "min" : 7845197, + "max" : 47422496, + "mean" : 19153993.597017, + "stddev" : 1027798.155847, + "N" : 49476, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21889024, + "99.900000" : 26869760, + "99.950000" : 29491200, + "99.990000" : 41680896 + } + }, + "lat_ns" : { + "min" : 8346437, + "max" : 49350953, + "mean" : 19397864.284482, + "stddev" : 1030365.188927, + "N" : 49476 + }, + "bw_min" : 6299648, + "bw_max" : 6782976, + "bw_agg" : 25.014983, + "bw_mean" : 6754436.813559, + "bw_dev" : 61320.436987, + "bw_samples" : 59, + "iops_min" : 1538, + "iops_max" : 1656, + "iops_mean" : 1648.949153, + "iops_stddev" : 14.972876, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.446414, + "sys_cpu" : 48.579138, + "ctx" : 34475, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937343, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997978, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.090953, + "20" : 85.415151, + "50" : 14.493896, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793783976224, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207492218880, + "io_kbytes" : 202629120, + "bw_bytes" : 6912259940, + "bw" : 6750253, + "iops" : 1648.011193, + "runtime" : 30018, + "total_ios" : 49470, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 165150, + "max" : 2113127, + "mean" : 243382.416495, + "stddev" : 65988.102891, + "N" : 49470 + }, + "clat_ns" : { + "min" : 7622678, + "max" : 47309556, + "mean" : 19156327.916353, + "stddev" : 1052574.340434, + "N" : 49470, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21889024, + "99.900000" : 27656192, + "99.950000" : 29753344, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8121547, + "max" : 49422683, + "mean" : 19399710.332848, + "stddev" : 1054662.320169, + "N" : 49470 + }, + "bw_min" : 6324224, + "bw_max" : 6791168, + "bw_agg" : 25.012409, + "bw_mean" : 6753741.186441, + "bw_dev" : 58828.153385, + "bw_samples" : 59, + "iops_min" : 1544, + "iops_max" : 1658, + "iops_mean" : 1648.779661, + "iops_stddev" : 14.355184, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.493054, + "sys_cpu" : 48.722391, + "ctx" : 34398, + "majf" : 0, + "minf" : 32778, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937336, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997977, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.095007, + "20" : 85.514453, + "50" : 14.390540, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1587997, + "write_ios" : 0, + "read_sectors" : 403376384, + "write_sectors" : 0, + "read_merges" : 20020, + "write_merges" : 0, + "read_ticks" : 28315675, + "write_ticks" : 0, + "in_queue" : 28315675, + "util" : 99.666266 + }, + { + "name" : "nvme2n1", + "read_ios" : 1592285, + "write_ios" : 0, + "read_sectors" : 403292928, + "write_sectors" : 0, + "read_merges" : 16938, + "write_merges" : 0, + "read_ticks" : 28435407, + "write_ticks" : 0, + "in_queue" : 28435407, + "util" : 99.699519 + }, + { + "name" : "nvme3n1", + "read_ios" : 1591190, + "write_ios" : 0, + "read_sectors" : 403406080, + "write_sectors" : 0, + "read_merges" : 23102, + "write_merges" : 0, + "read_ticks" : 28383410, + "write_ticks" : 0, + "in_queue" : 28383410, + "util" : 99.726165 + }, + { + "name" : "nvme4n1", + "read_ios" : 1589509, + "write_ios" : 0, + "read_sectors" : 403366400, + "write_sectors" : 0, + "read_merges" : 21565, + "write_merges" : 0, + "read_ticks" : 28359434, + "write_ticks" : 0, + "in_queue" : 28359434, + "util" : 99.826192 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_3.json new file mode 100644 index 0000000..629c1b6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/read_only_3.json @@ -0,0 +1,1073 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784128, + "timestamp_ms" : 1793784128269, + "time" : "Wed Nov 4 09:22:08 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784098191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207488024576, + "io_kbytes" : 202625024, + "bw_bytes" : 6912350487, + "bw" : 6750342, + "iops" : 1648.032781, + "runtime" : 30017, + "total_ios" : 49469, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158890, + "max" : 1787207, + "mean" : 242359.800724, + "stddev" : 72359.265187, + "N" : 49469 + }, + "clat_ns" : { + "min" : 8096867, + "max" : 47086293, + "mean" : 19157708.967616, + "stddev" : 1057150.252630, + "N" : 49469, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21626880, + "99.500000" : 21889024, + "99.900000" : 27131904, + "99.950000" : 30015488, + "99.990000" : 41680896 + } + }, + "lat_ns" : { + "min" : 8433526, + "max" : 48795960, + "mean" : 19400068.768340, + "stddev" : 1056736.174841, + "N" : 49469 + }, + "bw_min" : 6324224, + "bw_max" : 6799360, + "bw_agg" : 25.022337, + "bw_mean" : 6756490.372881, + "bw_dev" : 58351.791816, + "bw_samples" : 59, + "iops_min" : 1544, + "iops_max" : 1660, + "iops_mean" : 1649.355932, + "iops_stddev" : 14.241468, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30016, + "usr_cpu" : 0.403118, + "sys_cpu" : 48.763993, + "ctx" : 34353, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937334, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997977, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.107138, + "20" : 85.174554, + "50" : 14.718308, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784098191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207500607488, + "io_kbytes" : 202637312, + "bw_bytes" : 6912539392, + "bw" : 6750526, + "iops" : 1648.077820, + "runtime" : 30018, + "total_ios" : 49472, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 169720, + "max" : 1699118, + "mean" : 241371.339626, + "stddev" : 60022.516994, + "N" : 49472 + }, + "clat_ns" : { + "min" : 8498886, + "max" : 47244383, + "mean" : 19158366.845711, + "stddev" : 1004498.852191, + "N" : 49472, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21889024, + "99.900000" : 26083328, + "99.950000" : 29491200, + "99.990000" : 42205184 + } + }, + "lat_ns" : { + "min" : 8895685, + "max" : 48924440, + "mean" : 19399738.185337, + "stddev" : 1006491.589529, + "N" : 49472 + }, + "bw_min" : 6332416, + "bw_max" : 6791168, + "bw_agg" : 25.022334, + "bw_mean" : 6756489.830508, + "bw_dev" : 57163.700017, + "bw_samples" : 59, + "iops_min" : 1546, + "iops_max" : 1658, + "iops_mean" : 1649.355932, + "iops_stddev" : 13.947887, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.479728, + "sys_cpu" : 48.629110, + "ctx" : 34527, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937338, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997977, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.082875, + "20" : 85.589829, + "50" : 14.327296, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784098191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207492218880, + "io_kbytes" : 202629120, + "bw_bytes" : 6912259940, + "bw" : 6750253, + "iops" : 1648.011193, + "runtime" : 30018, + "total_ios" : 49470, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 173760, + "max" : 1870207, + "mean" : 249123.266404, + "stddev" : 61318.012856, + "N" : 49470 + }, + "clat_ns" : { + "min" : 8069657, + "max" : 47670821, + "mean" : 19151132.459774, + "stddev" : 1064233.030645, + "N" : 49470, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 19005440, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21889024, + "99.900000" : 28180480, + "99.950000" : 30539776, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 8513716, + "max" : 49541028, + "mean" : 19400255.726177, + "stddev" : 1066990.363180, + "N" : 49470 + }, + "bw_min" : 6291456, + "bw_max" : 6791168, + "bw_agg" : 25.021826, + "bw_mean" : 6756352.101695, + "bw_dev" : 62941.008246, + "bw_samples" : 59, + "iops_min" : 1536, + "iops_max" : 1658, + "iops_mean" : 1649.322034, + "iops_stddev" : 15.365030, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 0.473065, + "sys_cpu" : 49.835093, + "ctx" : 34082, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937336, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997977, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.099050, + "20" : 85.498282, + "50" : 14.402668, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784098191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 207513190400, + "io_kbytes" : 202649600, + "bw_bytes" : 6913188872, + "bw" : 6751161, + "iops" : 1648.232668, + "runtime" : 30017, + "total_ios" : 49475, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 151920, + "max" : 1675777, + "mean" : 274484.163194, + "stddev" : 100873.607251, + "N" : 49475 + }, + "clat_ns" : { + "min" : 8251397, + "max" : 46585754, + "mean" : 19123494.199556, + "stddev" : 1060209.316178, + "N" : 49475, + "percentile" : { + "1.000000" : 17432576, + "5.000000" : 17956864, + "10.000000" : 18219008, + "20.000000" : 18481152, + "30.000000" : 18743296, + "40.000000" : 18743296, + "50.000000" : 19005440, + "60.000000" : 19267584, + "70.000000" : 19529728, + "80.000000" : 19791872, + "90.000000" : 20316160, + "95.000000" : 20578304, + "99.000000" : 21364736, + "99.500000" : 21889024, + "99.900000" : 27656192, + "99.950000" : 30277632, + "99.990000" : 41156608 + } + }, + "lat_ns" : { + "min" : 8603086, + "max" : 48209441, + "mean" : 19397978.362749, + "stddev" : 1056516.990333, + "N" : 49475 + }, + "bw_min" : 6332416, + "bw_max" : 6799360, + "bw_agg" : 25.024393, + "bw_mean" : 6757045.491525, + "bw_dev" : 58808.276962, + "bw_samples" : 59, + "iops_min" : 1546, + "iops_max" : 1660, + "iops_mean" : 1649.491525, + "iops_stddev" : 14.353148, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30016, + "usr_cpu" : 0.509728, + "sys_cpu" : 53.571429, + "ctx" : 32097, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.937342, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997978, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.101061, + "20" : 86.009096, + "50" : 13.889843, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1584207, + "write_ios" : 0, + "read_sectors" : 403194368, + "write_sectors" : 0, + "read_merges" : 23082, + "write_merges" : 0, + "read_ticks" : 28235791, + "write_ticks" : 0, + "in_queue" : 28235791, + "util" : 99.636182 + }, + { + "name" : "nvme2n1", + "read_ios" : 1584267, + "write_ios" : 0, + "read_sectors" : 403209472, + "write_sectors" : 0, + "read_merges" : 18472, + "write_merges" : 0, + "read_ticks" : 28284941, + "write_ticks" : 0, + "in_queue" : 28284942, + "util" : 99.672766 + }, + { + "name" : "nvme3n1", + "read_ios" : 1584273, + "write_ios" : 0, + "read_sectors" : 403210240, + "write_sectors" : 0, + "read_merges" : 15392, + "write_merges" : 0, + "read_ticks" : 28264903, + "write_ticks" : 0, + "in_queue" : 28264903, + "util" : 99.692750 + }, + { + "name" : "nvme4n1", + "read_ios" : 1586009, + "write_ios" : 0, + "read_sectors" : 403260928, + "write_sectors" : 0, + "read_merges" : 16934, + "write_merges" : 0, + "read_ticks" : 28219675, + "write_ticks" : 0, + "in_queue" : 28219674, + "util" : 99.786068 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_1.json new file mode 100644 index 0000000..ebffcf8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_1.json @@ -0,0 +1,2089 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793783975, + "timestamp_ms" : 1793783975853, + "time" : "Wed Nov 4 09:19:35 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793783945745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155805810688, + "io_kbytes" : 152154112, + "bw_bytes" : 5188857051, + "bw" : 5067243, + "iops" : 1237.119925, + "runtime" : 30027, + "total_ios" : 37147, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 154050, + "max" : 1808107, + "mean" : 353525.157375, + "stddev" : 96231.582635, + "N" : 37147 + }, + "clat_ns" : { + "min" : 7563928, + "max" : 52593828, + "mean" : 25489907.627937, + "stddev" : 2136895.557340, + "N" : 37147, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 22675456, + "10.000000" : 23199744, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25296896, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27918336, + "95.000000" : 28704768, + "99.000000" : 31064064, + "99.500000" : 32899072, + "99.900000" : 40108032, + "99.950000" : 42729472, + "99.990000" : 50069504 + } + }, + "lat_ns" : { + "min" : 7844118, + "max" : 52985077, + "mean" : 25843432.785312, + "stddev" : 2131795.032932, + "N" : 37147 + }, + "bw_min" : 4694016, + "bw_max" : 5193728, + "bw_agg" : 25.103781, + "bw_mean" : 5066054.283333, + "bw_dev" : 89880.237033, + "bw_samples" : 60, + "iops_min" : 1146, + "iops_max" : 1268, + "iops_mean" : 1236.750000, + "iops_stddev" : 21.954981, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30026, + "usr_cpu" : 0.452941, + "sys_cpu" : 51.065743, + "ctx" : 23820, + "majf" : 0, + "minf" : 32782, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916548, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997306, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.040380, + "20" : 0.419953, + "50" : 99.531591, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793783945745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154379747328, + "io_kbytes" : 150761472, + "bw_bytes" : 5141706821, + "bw" : 5021198, + "iops" : 1225.878435, + "runtime" : 30025, + "total_ios" : 36807, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158640, + "max" : 1898727, + "mean" : 359556.131551, + "stddev" : 83721.260301, + "N" : 36807 + }, + "clat_ns" : { + "min" : 7804858, + "max" : 50018582, + "mean" : 25720841.764039, + "stddev" : 2101678.111872, + "N" : 36807, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22675456, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24772608, + "40.000000" : 25034752, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27131904, + "90.000000" : 28180480, + "95.000000" : 29229056, + "99.000000" : 31064064, + "99.500000" : 32112640, + "99.900000" : 38010880, + "99.950000" : 41680896, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 8055458, + "max" : 50392241, + "mean" : 26080397.895591, + "stddev" : 2096786.205151, + "N" : 36807 + }, + "bw_min" : 4751360, + "bw_max" : 5185536, + "bw_agg" : 24.873716, + "bw_mean" : 5019626.683333, + "bw_dev" : 79379.569432, + "bw_samples" : 60, + "iops_min" : 1160, + "iops_max" : 1266, + "iops_mean" : 1225.416667, + "iops_stddev" : 19.326185, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30024, + "usr_cpu" : 0.512923, + "sys_cpu" : 51.602052, + "ctx" : 23409, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915777, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997281, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.048904, + "20" : 0.201049, + "50" : 99.747331, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793783945745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154530742272, + "io_kbytes" : 150908928, + "bw_bytes" : 5146564386, + "bw" : 5025941, + "iops" : 1227.036568, + "runtime" : 30026, + "total_ios" : 36843, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 156630, + "max" : 1767377, + "mean" : 363790.015390, + "stddev" : 84261.343916, + "N" : 36843 + }, + "clat_ns" : { + "min" : 7694848, + "max" : 47514356, + "mean" : 25691571.798713, + "stddev" : 2092075.512082, + "N" : 36843, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22675456, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24772608, + "40.000000" : 25034752, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27131904, + "90.000000" : 28180480, + "95.000000" : 28966912, + "99.000000" : 31326208, + "99.500000" : 32374784, + "99.900000" : 38010880, + "99.950000" : 40108032, + "99.990000" : 45875200 + } + }, + "lat_ns" : { + "min" : 8023458, + "max" : 49259743, + "mean" : 26055361.814103, + "stddev" : 2087105.725130, + "N" : 36843 + }, + "bw_min" : 4841472, + "bw_max" : 5169152, + "bw_agg" : 24.898126, + "bw_mean" : 5024552.216667, + "bw_dev" : 70210.033051, + "bw_samples" : 60, + "iops_min" : 1182, + "iops_max" : 1262, + "iops_mean" : 1226.616667, + "iops_stddev" : 17.122779, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30025, + "usr_cpu" : 0.532889, + "sys_cpu" : 52.063281, + "ctx" : 23233, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915859, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997284, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.048856, + "20" : 0.255137, + "50" : 99.696007, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793783945745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155784839168, + "io_kbytes" : 152133632, + "bw_bytes" : 5188331418, + "bw" : 5066729, + "iops" : 1236.994605, + "runtime" : 30026, + "total_ios" : 37142, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 152979, + "max" : 1854797, + "mean" : 339520.404906, + "stddev" : 87625.805402, + "N" : 37142 + }, + "clat_ns" : { + "min" : 7567739, + "max" : 52327598, + "mean" : 25506641.255318, + "stddev" : 1959604.912322, + "N" : 37142, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22675456, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25296896, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27656192, + "95.000000" : 28704768, + "99.000000" : 30539776, + "99.500000" : 31326208, + "99.900000" : 39059456, + "99.950000" : 42729472, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 7852838, + "max" : 52659428, + "mean" : 25846161.660223, + "stddev" : 1954260.203204, + "N" : 37142 + }, + "bw_min" : 4751360, + "bw_max" : 5177344, + "bw_agg" : 25.100401, + "bw_mean" : 5065372.966667, + "bw_dev" : 79617.345986, + "bw_samples" : 60, + "iops_min" : 1160, + "iops_max" : 1264, + "iops_mean" : 1236.583333, + "iops_stddev" : 19.455548, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30025, + "usr_cpu" : 0.496253, + "sys_cpu" : 49.648626, + "ctx" : 24229, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916537, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997305, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.043078, + "20" : 0.164235, + "50" : 99.787303, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793783945780, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 181650, + "max" : 633399, + "mean" : 479660.648533, + "stddev" : 57140.275991, + "N" : 7500 + }, + "clat_ns" : { + "min" : 404010, + "max" : 2669046, + "mean" : 1013759.152000, + "stddev" : 297104.632431, + "N" : 7500, + "percentile" : { + "1.000000" : 485376, + "5.000000" : 577536, + "10.000000" : 634880, + "20.000000" : 741376, + "30.000000" : 831488, + "40.000000" : 913408, + "50.000000" : 995328, + "60.000000" : 1073152, + "70.000000" : 1155072, + "80.000000" : 1269760, + "90.000000" : 1417216, + "95.000000" : 1531904, + "99.000000" : 1777664, + "99.500000" : 1859584, + "99.900000" : 2056192, + "99.950000" : 2179072, + "99.990000" : 2670592 + } + }, + "lat_ns" : { + "min" : 734719, + "max" : 2912876, + "mean" : 1493419.800533, + "stddev" : 293376.699272, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.012675, + "bw_mean" : 1024485.779661, + "bw_dev" : 2827.312676, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.033898, + "iops_stddev" : 0.718382, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.456667, + "sys_cpu" : 12.006667, + "ctx" : 15002, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 1.440000, + "750" : 19.546667, + "1000" : 29.840000 + }, + "latency_ms" : { + "2" : 49.000000, + "4" : 0.173333, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793783945780, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 168720, + "max" : 548499, + "mean" : 424683.506667, + "stddev" : 38155.522329, + "N" : 7500 + }, + "clat_ns" : { + "min" : 474199, + "max" : 2900376, + "mean" : 1091707.476133, + "stddev" : 286806.616355, + "N" : 7500, + "percentile" : { + "1.000000" : 561152, + "5.000000" : 651264, + "10.000000" : 716800, + "20.000000" : 831488, + "30.000000" : 921600, + "40.000000" : 1003520, + "50.000000" : 1073152, + "60.000000" : 1155072, + "70.000000" : 1236992, + "80.000000" : 1335296, + "90.000000" : 1466368, + "95.000000" : 1581056, + "99.000000" : 1810432, + "99.500000" : 1892352, + "99.900000" : 2211840, + "99.950000" : 2506752, + "99.990000" : 2899968 + } + }, + "lat_ns" : { + "min" : 726519, + "max" : 3133105, + "mean" : 1516390.982800, + "stddev" : 284035.776280, + "N" : 7500 + }, + "bw_min" : 1021956, + "bw_max" : 1032192, + "bw_agg" : 25.012699, + "bw_mean" : 1024486.355932, + "bw_dev" : 2615.533576, + "bw_samples" : 59, + "iops_min" : 249, + "iops_max" : 252, + "iops_mean" : 250.033898, + "iops_stddev" : 0.718382, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.470000, + "sys_cpu" : 10.646667, + "ctx" : 15001, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.080000, + "750" : 12.360000, + "1000" : 26.866667 + }, + "latency_ms" : { + "2" : 60.453333, + "4" : 0.240000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793783945780, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 176390, + "max" : 576229, + "mean" : 459006.515733, + "stddev" : 40522.662491, + "N" : 7500 + }, + "clat_ns" : { + "min" : 439749, + "max" : 2996855, + "mean" : 1066389.263333, + "stddev" : 288048.540318, + "N" : 7500, + "percentile" : { + "1.000000" : 522240, + "5.000000" : 626688, + "10.000000" : 692224, + "20.000000" : 806912, + "30.000000" : 897024, + "40.000000" : 978944, + "50.000000" : 1056768, + "60.000000" : 1122304, + "70.000000" : 1204224, + "80.000000" : 1302528, + "90.000000" : 1449984, + "95.000000" : 1564672, + "99.000000" : 1777664, + "99.500000" : 1875968, + "99.900000" : 2072576, + "99.950000" : 2211840, + "99.990000" : 2998272 + } + }, + "lat_ns" : { + "min" : 727929, + "max" : 3216414, + "mean" : 1525395.779067, + "stddev" : 283587.004575, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.012699, + "bw_mean" : 1024486.067797, + "bw_dev" : 3299.773424, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.033898, + "iops_stddev" : 0.850276, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.656667, + "sys_cpu" : 11.353333, + "ctx" : 15003, + "majf" : 0, + "minf" : 16, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.573333, + "750" : 14.533333, + "1000" : 27.213333 + }, + "latency_ms" : { + "2" : 57.546667, + "4" : 0.133333, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793783945780, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163820, + "max" : 566529, + "mean" : 423184.297867, + "stddev" : 39724.461429, + "N" : 7500 + }, + "clat_ns" : { + "min" : 479509, + "max" : 2577656, + "mean" : 1065972.650000, + "stddev" : 283649.330484, + "N" : 7500, + "percentile" : { + "1.000000" : 552960, + "5.000000" : 634880, + "10.000000" : 700416, + "20.000000" : 806912, + "30.000000" : 888832, + "40.000000" : 970752, + "50.000000" : 1056768, + "60.000000" : 1122304, + "70.000000" : 1204224, + "80.000000" : 1302528, + "90.000000" : 1449984, + "95.000000" : 1564672, + "99.000000" : 1761280, + "99.500000" : 1859584, + "99.900000" : 2072576, + "99.950000" : 2244608, + "99.990000" : 2572288 + } + }, + "lat_ns" : { + "min" : 739149, + "max" : 3038905, + "mean" : 1489156.947867, + "stddev" : 283661.806509, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.012699, + "bw_mean" : 1024486.067797, + "bw_dev" : 2928.208649, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.033898, + "iops_stddev" : 0.764878, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.660000, + "sys_cpu" : 10.406667, + "ctx" : 15003, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.066667, + "750" : 14.306667, + "1000" : 28.706667 + }, + "latency_ms" : { + "2" : 56.773333, + "4" : 0.146667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1188629, + "write_ios" : 238699, + "read_sectors" : 302810624, + "write_sectors" : 61106944, + "read_merges" : 10411, + "write_merges" : 0, + "read_ticks" : 27813592, + "write_ticks" : 110715, + "in_queue" : 27924308, + "util" : 99.659557 + }, + { + "name" : "nvme2n1", + "read_ios" : 1177614, + "write_ios" : 238706, + "read_sectors" : 300004352, + "write_sectors" : 61108736, + "read_merges" : 8018, + "write_merges" : 0, + "read_ticks" : 27669297, + "write_ticks" : 118415, + "in_queue" : 27787711, + "util" : 99.709487 + }, + { + "name" : "nvme3n1", + "read_ios" : 1180964, + "write_ios" : 238708, + "read_sectors" : 300273152, + "write_sectors" : 61109248, + "read_merges" : 5731, + "write_merges" : 0, + "read_ticks" : 27771519, + "write_ticks" : 115604, + "in_queue" : 27887122, + "util" : 99.739488 + }, + { + "name" : "nvme4n1", + "read_ios" : 1188493, + "write_ios" : 238720, + "read_sectors" : 302775656, + "write_sectors" : 61112320, + "read_merges" : 6941, + "write_merges" : 0, + "read_ticks" : 27904153, + "write_ticks" : 115419, + "in_queue" : 28019572, + "util" : 99.816140 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_2.json new file mode 100644 index 0000000..86b7279 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_2.json @@ -0,0 +1,2089 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784097, + "timestamp_ms" : 1793784097817, + "time" : "Wed Nov 4 09:21:37 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784067708, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155797422080, + "io_kbytes" : 152145920, + "bw_bytes" : 5188923299, + "bw" : 5067307, + "iops" : 1237.135720, + "runtime" : 30025, + "total_ios" : 37145, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 155000, + "max" : 2055786, + "mean" : 328132.586028, + "stddev" : 100579.396431, + "N" : 37145 + }, + "clat_ns" : { + "min" : 7798988, + "max" : 50741577, + "mean" : 25514882.045174, + "stddev" : 2001856.382586, + "N" : 37145, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25296896, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27656192, + "95.000000" : 28704768, + "99.000000" : 30801920, + "99.500000" : 32112640, + "99.900000" : 39059456, + "99.950000" : 41156608, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 8110357, + "max" : 51125327, + "mean" : 25843014.631202, + "stddev" : 1996070.167965, + "N" : 37145 + }, + "bw_min" : 4825088, + "bw_max" : 5193728, + "bw_agg" : 25.154063, + "bw_mean" : 5069373.508475, + "bw_dev" : 69191.374112, + "bw_samples" : 59, + "iops_min" : 1178, + "iops_max" : 1268, + "iops_mean" : 1237.508475, + "iops_stddev" : 16.871086, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30024, + "usr_cpu" : 0.396350, + "sys_cpu" : 48.507860, + "ctx" : 24626, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916543, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997306, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.048459, + "20" : 0.312290, + "50" : 99.633867, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784067708, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154102923264, + "io_kbytes" : 150491136, + "bw_bytes" : 5132145178, + "bw" : 5011860, + "iops" : 1223.598761, + "runtime" : 30027, + "total_ios" : 36741, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 152580, + "max" : 2027307, + "mean" : 357159.088593, + "stddev" : 95110.676581, + "N" : 36741 + }, + "clat_ns" : { + "min" : 7753608, + "max" : 50693807, + "mean" : 25770819.664081, + "stddev" : 2154881.771170, + "N" : 36741, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 24248320, + "30.000000" : 24772608, + "40.000000" : 25034752, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27394048, + "90.000000" : 28442624, + "95.000000" : 29229056, + "99.000000" : 31588352, + "99.500000" : 32636928, + "99.900000" : 39583744, + "99.950000" : 42205184, + "99.990000" : 47972352 + } + }, + "lat_ns" : { + "min" : 8066907, + "max" : 51173916, + "mean" : 26127978.752674, + "stddev" : 2150047.464752, + "N" : 36741 + }, + "bw_min" : 4775936, + "bw_max" : 5218304, + "bw_agg" : 24.883487, + "bw_mean" : 5014843.593220, + "bw_dev" : 90662.583965, + "bw_samples" : 59, + "iops_min" : 1166, + "iops_max" : 1274, + "iops_mean" : 1224.186441, + "iops_stddev" : 22.145658, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30026, + "usr_cpu" : 0.416306, + "sys_cpu" : 51.695197, + "ctx" : 23294, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915626, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997276, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.040826, + "20" : 0.234071, + "50" : 99.722381, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784067708, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154367164416, + "io_kbytes" : 150749184, + "bw_bytes" : 5140945296, + "bw" : 5020454, + "iops" : 1225.696873, + "runtime" : 30027, + "total_ios" : 36804, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 140940, + "max" : 1995887, + "mean" : 354865.955440, + "stddev" : 87838.027809, + "N" : 36804 + }, + "clat_ns" : { + "min" : 7975517, + "max" : 50214198, + "mean" : 25728410.073633, + "stddev" : 2044566.019309, + "N" : 36804, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 24248320, + "30.000000" : 24772608, + "40.000000" : 25034752, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27131904, + "90.000000" : 28180480, + "95.000000" : 28966912, + "99.000000" : 31064064, + "99.500000" : 31850496, + "99.900000" : 36962304, + "99.950000" : 41156608, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 8291887, + "max" : 50627067, + "mean" : 26083276.029073, + "stddev" : 2039098.920764, + "N" : 36804 + }, + "bw_min" : 4710400, + "bw_max" : 5160960, + "bw_agg" : 24.929604, + "bw_mean" : 5024137.474576, + "bw_dev" : 84982.498620, + "bw_samples" : 59, + "iops_min" : 1150, + "iops_max" : 1260, + "iops_mean" : 1226.457627, + "iops_stddev" : 20.750839, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30026, + "usr_cpu" : 0.532872, + "sys_cpu" : 51.545327, + "ctx" : 23338, + "majf" : 0, + "minf" : 32782, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915770, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997281, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.051625, + "20" : 0.182045, + "50" : 99.763613, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784067708, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155398963200, + "io_kbytes" : 151756800, + "bw_bytes" : 5175480023, + "bw" : 5054179, + "iops" : 1233.930593, + "runtime" : 30026, + "total_ios" : 37050, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 160650, + "max" : 1925167, + "mean" : 360003.324750, + "stddev" : 82812.232415, + "N" : 37050 + }, + "clat_ns" : { + "min" : 7460848, + "max" : 48389651, + "mean" : 25549404.232820, + "stddev" : 1972707.005704, + "N" : 37050, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25559040, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27918336, + "95.000000" : 28704768, + "99.000000" : 30539776, + "99.500000" : 31850496, + "99.900000" : 38535168, + "99.950000" : 41156608, + "99.990000" : 46923776 + } + }, + "lat_ns" : { + "min" : 7696848, + "max" : 49291920, + "mean" : 25909407.557571, + "stddev" : 1967353.982815, + "N" : 37050 + }, + "bw_min" : 4710400, + "bw_max" : 5177344, + "bw_agg" : 25.090699, + "bw_mean" : 5056603.135593, + "bw_dev" : 78398.870049, + "bw_samples" : 59, + "iops_min" : 1150, + "iops_max" : 1264, + "iops_mean" : 1234.389831, + "iops_stddev" : 19.114011, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30025, + "usr_cpu" : 0.472939, + "sys_cpu" : 52.459617, + "ctx" : 23296, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916329, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997299, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.045884, + "20" : 0.245614, + "50" : 99.708502, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784067743, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 193660, + "max" : 698779, + "mean" : 469182.452267, + "stddev" : 74396.410071, + "N" : 7500 + }, + "clat_ns" : { + "min" : 398339, + "max" : 2671096, + "mean" : 1027321.542667, + "stddev" : 294259.143055, + "N" : 7500, + "percentile" : { + "1.000000" : 489472, + "5.000000" : 577536, + "10.000000" : 651264, + "20.000000" : 757760, + "30.000000" : 856064, + "40.000000" : 937984, + "50.000000" : 1011712, + "60.000000" : 1089536, + "70.000000" : 1171456, + "80.000000" : 1269760, + "90.000000" : 1417216, + "95.000000" : 1531904, + "99.000000" : 1777664, + "99.500000" : 1859584, + "99.900000" : 2310144, + "99.950000" : 2506752, + "99.990000" : 2670592 + } + }, + "lat_ns" : { + "min" : 751199, + "max" : 3090745, + "mean" : 1496503.994933, + "stddev" : 290765.223512, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.014359, + "bw_mean" : 1024554.169492, + "bw_dev" : 3174.394067, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.000000, + "iops_stddev" : 0.742781, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.420000, + "sys_cpu" : 11.730000, + "ctx" : 15002, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 1.240000, + "750" : 17.693333, + "1000" : 29.173333 + }, + "latency_ms" : { + "2" : 51.626667, + "4" : 0.266667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784067743, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 169670, + "max" : 539229, + "mean" : 432129.846133, + "stddev" : 54205.494293, + "N" : 7500 + }, + "clat_ns" : { + "min" : 451909, + "max" : 2402016, + "mean" : 1090890.644400, + "stddev" : 287903.308623, + "N" : 7500, + "percentile" : { + "1.000000" : 544768, + "5.000000" : 634880, + "10.000000" : 716800, + "20.000000" : 831488, + "30.000000" : 921600, + "40.000000" : 1003520, + "50.000000" : 1073152, + "60.000000" : 1155072, + "70.000000" : 1236992, + "80.000000" : 1335296, + "90.000000" : 1466368, + "95.000000" : 1581056, + "99.000000" : 1810432, + "99.500000" : 1892352, + "99.900000" : 2072576, + "99.950000" : 2310144, + "99.990000" : 2408448 + } + }, + "lat_ns" : { + "min" : 742659, + "max" : 2836125, + "mean" : 1523020.490533, + "stddev" : 284903.996998, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.014384, + "bw_mean" : 1024555.033898, + "bw_dev" : 3759.372613, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.000000, + "iops_stddev" : 0.946864, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.560000, + "sys_cpu" : 10.743333, + "ctx" : 15005, + "majf" : 0, + "minf" : 11, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.173333, + "750" : 12.733333, + "1000" : 26.360000 + }, + "latency_ms" : { + "2" : 60.586667, + "4" : 0.146667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784067742, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 176060, + "max" : 738829, + "mean" : 478785.158800, + "stddev" : 75251.403730, + "N" : 7500 + }, + "clat_ns" : { + "min" : 412679, + "max" : 2428256, + "mean" : 1043459.915867, + "stddev" : 289494.151296, + "N" : 7500, + "percentile" : { + "1.000000" : 497664, + "5.000000" : 593920, + "10.000000" : 667648, + "20.000000" : 782336, + "30.000000" : 872448, + "40.000000" : 954368, + "50.000000" : 1036288, + "60.000000" : 1105920, + "70.000000" : 1187840, + "80.000000" : 1286144, + "90.000000" : 1433600, + "95.000000" : 1548288, + "99.000000" : 1761280, + "99.500000" : 1843200, + "99.900000" : 1990656, + "99.950000" : 2072576, + "99.990000" : 2441216 + } + }, + "lat_ns" : { + "min" : 745899, + "max" : 2643926, + "mean" : 1522245.074667, + "stddev" : 283920.576444, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.014359, + "bw_mean" : 1024554.745763, + "bw_dev" : 2987.309230, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.000000, + "iops_stddev" : 0.742781, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 1.210000, + "sys_cpu" : 13.220000, + "ctx" : 15004, + "majf" : 0, + "minf" : 15, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 1.093333, + "750" : 16.000000, + "1000" : 28.480000 + }, + "latency_ms" : { + "2" : 54.346667, + "4" : 0.080000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784067742, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 179540, + "max" : 606309, + "mean" : 475134.075200, + "stddev" : 44778.667151, + "N" : 7500 + }, + "clat_ns" : { + "min" : 419249, + "max" : 2639636, + "mean" : 1028605.246933, + "stddev" : 291724.569408, + "N" : 7500, + "percentile" : { + "1.000000" : 505856, + "5.000000" : 585728, + "10.000000" : 659456, + "20.000000" : 757760, + "30.000000" : 856064, + "40.000000" : 929792, + "50.000000" : 1011712, + "60.000000" : 1089536, + "70.000000" : 1171456, + "80.000000" : 1269760, + "90.000000" : 1417216, + "95.000000" : 1548288, + "99.000000" : 1761280, + "99.500000" : 1843200, + "99.900000" : 2179072, + "99.950000" : 2277376, + "99.990000" : 2637824 + } + }, + "lat_ns" : { + "min" : 742669, + "max" : 3098125, + "mean" : 1503739.322133, + "stddev" : 288061.512900, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.014359, + "bw_mean" : 1024554.745763, + "bw_dev" : 2987.309230, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.000000, + "iops_stddev" : 0.742781, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.203333, + "sys_cpu" : 12.190000, + "ctx" : 15004, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.933333, + "750" : 17.906667, + "1000" : 29.653333 + }, + "latency_ms" : { + "2" : 51.360000, + "4" : 0.146667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1187917, + "write_ios" : 238592, + "read_sectors" : 302629376, + "write_sectors" : 61079552, + "read_merges" : 9253, + "write_merges" : 0, + "read_ticks" : 27865674, + "write_ticks" : 112347, + "in_queue" : 27978021, + "util" : 99.659421 + }, + { + "name" : "nvme2n1", + "read_ios" : 1173831, + "write_ios" : 238592, + "read_sectors" : 299333120, + "write_sectors" : 61079552, + "read_merges" : 5715, + "write_merges" : 0, + "read_ticks" : 27614093, + "write_ticks" : 118462, + "in_queue" : 27732555, + "util" : 99.712701 + }, + { + "name" : "nvme3n1", + "read_ios" : 1177069, + "write_ios" : 238612, + "read_sectors" : 299866112, + "write_sectors" : 61084672, + "read_merges" : 5724, + "write_merges" : 0, + "read_ticks" : 27728054, + "write_ticks" : 114295, + "in_queue" : 27842348, + "util" : 99.719336 + }, + { + "name" : "nvme4n1", + "read_ios" : 1184816, + "write_ios" : 238624, + "read_sectors" : 301837824, + "write_sectors" : 61087744, + "read_merges" : 5760, + "write_merges" : 0, + "read_ticks" : 27830001, + "write_ticks" : 111869, + "in_queue" : 27941870, + "util" : 99.812715 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_3.json new file mode 100644 index 0000000..3ee326f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_1000_each_3.json @@ -0,0 +1,2089 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784219, + "timestamp_ms" : 1793784219800, + "time" : "Wed Nov 4 09:23:39 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784189693, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155696758784, + "io_kbytes" : 152047616, + "bw_bytes" : 5185397947, + "bw" : 5063865, + "iops" : 1236.295211, + "runtime" : 30026, + "total_ios" : 37121, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 152840, + "max" : 1936816, + "mean" : 349348.708386, + "stddev" : 83358.659945, + "N" : 37121 + }, + "clat_ns" : { + "min" : 7554327, + "max" : 51644062, + "mean" : 25510997.492498, + "stddev" : 2059247.243679, + "N" : 37121, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25296896, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27918336, + "95.000000" : 28704768, + "99.000000" : 30801920, + "99.500000" : 32112640, + "99.900000" : 39583744, + "99.950000" : 42729472, + "99.990000" : 46923776 + } + }, + "lat_ns" : { + "min" : 7894216, + "max" : 51919592, + "mean" : 25860346.200884, + "stddev" : 2055402.355321, + "N" : 37121 + }, + "bw_min" : 4841472, + "bw_max" : 5201920, + "bw_agg" : 25.168081, + "bw_mean" : 5071646.440678, + "bw_dev" : 76140.690525, + "bw_samples" : 59, + "iops_min" : 1182, + "iops_max" : 1270, + "iops_mean" : 1238.186441, + "iops_stddev" : 18.583896, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30025, + "usr_cpu" : 0.446295, + "sys_cpu" : 51.077435, + "ctx" : 23704, + "majf" : 0, + "minf" : 32778, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916489, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997304, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.051184, + "20" : 0.363676, + "50" : 99.582447, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784189693, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154056785920, + "io_kbytes" : 150446080, + "bw_bytes" : 5131121300, + "bw" : 5010860, + "iops" : 1223.354650, + "runtime" : 30024, + "total_ios" : 36730, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 150679, + "max" : 1967757, + "mean" : 362171.548026, + "stddev" : 86146.663508, + "N" : 36730 + }, + "clat_ns" : { + "min" : 7874947, + "max" : 50582454, + "mean" : 25771704.419004, + "stddev" : 2057869.500555, + "N" : 36730, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 24248320, + "30.000000" : 24772608, + "40.000000" : 25296896, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27394048, + "90.000000" : 28180480, + "95.000000" : 29229056, + "99.000000" : 31064064, + "99.500000" : 31850496, + "99.900000" : 36962304, + "99.950000" : 41156608, + "99.990000" : 47972352 + } + }, + "lat_ns" : { + "min" : 8184107, + "max" : 50971703, + "mean" : 26133875.967029, + "stddev" : 2051939.357202, + "N" : 36730 + }, + "bw_min" : 4784128, + "bw_max" : 5193728, + "bw_agg" : 24.902820, + "bw_mean" : 5018193.762712, + "bw_dev" : 85626.459940, + "bw_samples" : 59, + "iops_min" : 1168, + "iops_max" : 1268, + "iops_mean" : 1225.135593, + "iops_stddev" : 20.905747, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30023, + "usr_cpu" : 0.572894, + "sys_cpu" : 52.170003, + "ctx" : 22980, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915600, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997275, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.046284, + "20" : 0.147019, + "50" : 99.803975, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784189693, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 154115506176, + "io_kbytes" : 150503424, + "bw_bytes" : 5132906117, + "bw" : 5012603, + "iops" : 1223.780183, + "runtime" : 30025, + "total_ios" : 36744, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 162569, + "max" : 2027976, + "mean" : 350174.288863, + "stddev" : 82672.286971, + "N" : 36744 + }, + "clat_ns" : { + "min" : 7506417, + "max" : 48857627, + "mean" : 25774521.833551, + "stddev" : 2067968.734994, + "N" : 36744, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 24248320, + "30.000000" : 24772608, + "40.000000" : 25296896, + "50.000000" : 25559040, + "60.000000" : 26083328, + "70.000000" : 26607616, + "80.000000" : 27131904, + "90.000000" : 28180480, + "95.000000" : 29229056, + "99.000000" : 31326208, + "99.500000" : 32112640, + "99.900000" : 38535168, + "99.950000" : 40632320, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 7761587, + "max" : 49573906, + "mean" : 26124696.122415, + "stddev" : 2062916.480999, + "N" : 36744 + }, + "bw_min" : 4816896, + "bw_max" : 5177344, + "bw_agg" : 24.907644, + "bw_mean" : 5019165.423729, + "bw_dev" : 80080.301015, + "bw_samples" : 59, + "iops_min" : 1176, + "iops_max" : 1264, + "iops_mean" : 1225.372881, + "iops_stddev" : 19.550905, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30024, + "usr_cpu" : 0.566214, + "sys_cpu" : 50.766054, + "ctx" : 23549, + "majf" : 0, + "minf" : 32778, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.915632, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997276, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.046266, + "20" : 0.195950, + "50" : 99.757784, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784189693, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 155709341696, + "io_kbytes" : 152059904, + "bw_bytes" : 5185817015, + "bw" : 5064274, + "iops" : 1236.395124, + "runtime" : 30026, + "total_ios" : 37124, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163950, + "max" : 1875457, + "mean" : 362127.095949, + "stddev" : 92169.778614, + "N" : 37124 + }, + "clat_ns" : { + "min" : 7657537, + "max" : 50420195, + "mean" : 25496123.276452, + "stddev" : 2056616.259046, + "N" : 37124, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22675456, + "10.000000" : 23199744, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 25034752, + "50.000000" : 25296896, + "60.000000" : 25821184, + "70.000000" : 26345472, + "80.000000" : 26869760, + "90.000000" : 27918336, + "95.000000" : 28704768, + "99.000000" : 30801920, + "99.500000" : 31850496, + "99.900000" : 39583744, + "99.950000" : 42205184, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 7946697, + "max" : 50696405, + "mean" : 25858250.372401, + "stddev" : 2052009.190314, + "N" : 37124 + }, + "bw_min" : 4833280, + "bw_max" : 5259264, + "bw_agg" : 25.164637, + "bw_mean" : 5070952.745763, + "bw_dev" : 87208.857821, + "bw_samples" : 59, + "iops_min" : 1180, + "iops_max" : 1284, + "iops_mean" : 1238.016949, + "iops_stddev" : 21.288245, + "iops_samples" : 59 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30025, + "usr_cpu" : 0.542881, + "sys_cpu" : 52.529559, + "ctx" : 23229, + "majf" : 0, + "minf" : 32777, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.916496, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.997304, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.051180, + "20" : 0.315160, + "50" : 99.628273, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784189728, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 175369, + "max" : 632149, + "mean" : 408912.439333, + "stddev" : 72225.490839, + "N" : 7500 + }, + "clat_ns" : { + "min" : 427269, + "max" : 2724775, + "mean" : 1065315.672933, + "stddev" : 292707.643007, + "N" : 7500, + "percentile" : { + "1.000000" : 536576, + "5.000000" : 626688, + "10.000000" : 692224, + "20.000000" : 798720, + "30.000000" : 880640, + "40.000000" : 970752, + "50.000000" : 1044480, + "60.000000" : 1122304, + "70.000000" : 1220608, + "80.000000" : 1318912, + "90.000000" : 1449984, + "95.000000" : 1564672, + "99.000000" : 1777664, + "99.500000" : 1859584, + "99.900000" : 2342912, + "99.950000" : 2408448, + "99.990000" : 2736128 + } + }, + "lat_ns" : { + "min" : 750239, + "max" : 2956395, + "mean" : 1474228.112267, + "stddev" : 295017.454598, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.036430, + "bw_mean" : 1025458.169492, + "bw_dev" : 3628.694328, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.322034, + "iops_stddev" : 0.918032, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.223333, + "sys_cpu" : 10.273333, + "ctx" : 15005, + "majf" : 0, + "minf" : 11, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.240000, + "750" : 15.160000, + "1000" : 28.213333 + }, + "latency_ms" : { + "2" : 56.173333, + "4" : 0.213333, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784189728, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 174350, + "max" : 549609, + "mean" : 425470.874267, + "stddev" : 30398.010805, + "N" : 7500 + }, + "clat_ns" : { + "min" : 505469, + "max" : 3300954, + "mean" : 1104497.414000, + "stddev" : 285926.368594, + "N" : 7500, + "percentile" : { + "1.000000" : 577536, + "5.000000" : 667648, + "10.000000" : 741376, + "20.000000" : 847872, + "30.000000" : 937984, + "40.000000" : 1019904, + "50.000000" : 1089536, + "60.000000" : 1171456, + "70.000000" : 1236992, + "80.000000" : 1335296, + "90.000000" : 1482752, + "95.000000" : 1597440, + "99.000000" : 1810432, + "99.500000" : 1908736, + "99.900000" : 2179072, + "99.950000" : 2801664, + "99.990000" : 3293184 + } + }, + "lat_ns" : { + "min" : 754949, + "max" : 3488564, + "mean" : 1529968.288267, + "stddev" : 282007.994084, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.036406, + "bw_mean" : 1025457.881356, + "bw_dev" : 3547.856177, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.322034, + "iops_stddev" : 0.879668, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 1.413333, + "sys_cpu" : 11.793333, + "ctx" : 15001, + "majf" : 0, + "minf" : 10, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 10.840000, + "1000" : 26.746667 + }, + "latency_ms" : { + "2" : 62.146667, + "4" : 0.266667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784189727, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 164360, + "max" : 530189, + "mean" : 418156.520267, + "stddev" : 39121.494808, + "N" : 7500 + }, + "clat_ns" : { + "min" : 487699, + "max" : 2786335, + "mean" : 1102796.020000, + "stddev" : 278738.861895, + "N" : 7500, + "percentile" : { + "1.000000" : 577536, + "5.000000" : 667648, + "10.000000" : 733184, + "20.000000" : 847872, + "30.000000" : 937984, + "40.000000" : 1019904, + "50.000000" : 1089536, + "60.000000" : 1171456, + "70.000000" : 1253376, + "80.000000" : 1335296, + "90.000000" : 1466368, + "95.000000" : 1581056, + "99.000000" : 1794048, + "99.500000" : 1859584, + "99.900000" : 2056192, + "99.950000" : 2179072, + "99.990000" : 2801664 + } + }, + "lat_ns" : { + "min" : 742149, + "max" : 3143364, + "mean" : 1520952.540267, + "stddev" : 277595.845716, + "N" : 7500 + }, + "bw_min" : 1021956, + "bw_max" : 1032192, + "bw_agg" : 25.035576, + "bw_mean" : 1025423.389831, + "bw_dev" : 3298.889662, + "bw_samples" : 59, + "iops_min" : 249, + "iops_max" : 252, + "iops_mean" : 250.322034, + "iops_stddev" : 0.839554, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.486667, + "sys_cpu" : 10.493333, + "ctx" : 15006, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.013333, + "750" : 10.800000, + "1000" : 26.573333 + }, + "latency_ms" : { + "2" : 62.466667, + "4" : 0.146667, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784189728, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "rate" : "1000m" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 31457280000, + "io_kbytes" : 30720000, + "bw_bytes" : 1048541048, + "bw" : 1023965, + "iops" : 249.991667, + "runtime" : 30001, + "total_ios" : 7500, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163510, + "max" : 541489, + "mean" : 413704.488533, + "stddev" : 36338.632431, + "N" : 7500 + }, + "clat_ns" : { + "min" : 443800, + "max" : 2552556, + "mean" : 1079401.201600, + "stddev" : 289727.246025, + "N" : 7500, + "percentile" : { + "1.000000" : 561152, + "5.000000" : 643072, + "10.000000" : 708608, + "20.000000" : 815104, + "30.000000" : 897024, + "40.000000" : 978944, + "50.000000" : 1056768, + "60.000000" : 1138688, + "70.000000" : 1236992, + "80.000000" : 1335296, + "90.000000" : 1466368, + "95.000000" : 1581056, + "99.000000" : 1810432, + "99.500000" : 1875968, + "99.900000" : 2113536, + "99.950000" : 2146304, + "99.990000" : 2539520 + } + }, + "lat_ns" : { + "min" : 750119, + "max" : 3002255, + "mean" : 1493105.690133, + "stddev" : 288903.698158, + "N" : 7500 + }, + "bw_min" : 1015808, + "bw_max" : 1032192, + "bw_agg" : 25.036430, + "bw_mean" : 1025458.169492, + "bw_dev" : 3628.694328, + "bw_samples" : 59, + "iops_min" : 248, + "iops_max" : 252, + "iops_mean" : 250.322034, + "iops_stddev" : 0.918032, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30000, + "usr_cpu" : 2.240000, + "sys_cpu" : 10.610000, + "ctx" : 15004, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 100.000000, + "2" : 0.000000, + "4" : 0.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.040000, + "750" : 13.533333, + "1000" : 28.840000 + }, + "latency_ms" : { + "2" : 57.346667, + "4" : 0.240000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 1186568, + "write_ios" : 238464, + "read_sectors" : 302285824, + "write_sectors" : 61046784, + "read_merges" : 8081, + "write_merges" : 0, + "read_ticks" : 27834894, + "write_ticks" : 116244, + "in_queue" : 27951138, + "util" : 99.622642 + }, + { + "name" : "nvme2n1", + "read_ios" : 1172980, + "write_ios" : 238464, + "read_sectors" : 299112960, + "write_sectors" : 61046784, + "read_merges" : 5710, + "write_merges" : 0, + "read_ticks" : 27639358, + "write_ticks" : 118714, + "in_queue" : 27758072, + "util" : 99.659228 + }, + { + "name" : "nvme3n1", + "read_ios" : 1173324, + "write_ios" : 238464, + "read_sectors" : 299202824, + "write_sectors" : 61046784, + "read_merges" : 6852, + "write_merges" : 0, + "read_ticks" : 27665930, + "write_ticks" : 119458, + "in_queue" : 27785389, + "util" : 99.672537 + }, + { + "name" : "nvme4n1", + "read_ios" : 1183063, + "write_ios" : 238464, + "read_sectors" : 302274048, + "write_sectors" : 61046784, + "read_merges" : 10392, + "write_merges" : 0, + "read_ticks" : 27778299, + "write_ticks" : 116424, + "in_queue" : 27894723, + "util" : 99.779257 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_1.json new file mode 100644 index 0000000..83640ea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_1.json @@ -0,0 +1,2085 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793783914, + "timestamp_ms" : 1793783914846, + "time" : "Wed Nov 4 09:18:34 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793783884711, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80580968448, + "io_kbytes" : 78692352, + "bw_bytes" : 2681027696, + "bw" : 2618191, + "iops" : 639.206814, + "runtime" : 30056, + "total_ios" : 19212, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 160470, + "max" : 2197347, + "mean" : 606944.558974, + "stddev" : 223262.897827, + "N" : 19212 + }, + "clat_ns" : { + "min" : 12606511, + "max" : 104884391, + "mean" : 49408093.630491, + "stddev" : 4918846.036276, + "N" : 19212, + "percentile" : { + "1.000000" : 22675456, + "5.000000" : 45875200, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 50069504, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52690944, + "99.000000" : 62652416, + "99.500000" : 65273856, + "99.900000" : 78118912, + "99.950000" : 89653248, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 13777029, + "max" : 105385700, + "mean" : 50015038.189465, + "stddev" : 4932295.406608, + "N" : 19212 + }, + "bw_min" : 2424832, + "bw_max" : 2744320, + "bw_agg" : 25.170234, + "bw_mean" : 2618760.566667, + "bw_dev" : 66822.618570, + "bw_samples" : 60, + "iops_min" : 592, + "iops_max" : 670, + "iops_mean" : 639.333333, + "iops_stddev" : 16.325779, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30055, + "usr_cpu" : 0.362668, + "sys_cpu" : 39.970055, + "ctx" : 19632, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838643, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994787, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.692276, + "50" : 53.112638, + "100" : 46.179471, + "250" : 0.015615, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793783884711, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 79909879808, + "io_kbytes" : 78036992, + "bw_bytes" : 2658522849, + "bw" : 2596213, + "iops" : 633.841240, + "runtime" : 30058, + "total_ios" : 19052, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 161869, + "max" : 2301827, + "mean" : 580929.057264, + "stddev" : 164830.315482, + "N" : 19052 + }, + "clat_ns" : { + "min" : 12923051, + "max" : 102355775, + "mean" : 49857937.947722, + "stddev" : 3652749.964853, + "N" : 19052, + "percentile" : { + "1.000000" : 40108032, + "5.000000" : 46923776, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 50069504, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52690944, + "99.000000" : 62652416, + "99.500000" : 65798144, + "99.900000" : 78118912, + "99.950000" : 89653248, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 14306159, + "max" : 103012384, + "mean" : 50438867.004987, + "stddev" : 3654874.017231, + "N" : 19052 + }, + "bw_min" : 2400256, + "bw_max" : 2714315, + "bw_agg" : 24.960222, + "bw_mean" : 2596910.050000, + "bw_dev" : 56248.095083, + "bw_samples" : 60, + "iops_min" : 586, + "iops_max" : 662, + "iops_mean" : 634.000000, + "iops_stddev" : 13.708837, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.372625, + "sys_cpu" : 41.574342, + "ctx" : 17754, + "majf" : 0, + "minf" : 32782, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.837287, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994743, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.225698, + "50" : 52.445937, + "100" : 47.312618, + "250" : 0.015746, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793783884711, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 79695970304, + "io_kbytes" : 77828096, + "bw_bytes" : 2651406291, + "bw" : 2589263, + "iops" : 632.144521, + "runtime" : 30058, + "total_ios" : 19001, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163450, + "max" : 2418746, + "mean" : 621883.416399, + "stddev" : 237420.695342, + "N" : 19001 + }, + "clat_ns" : { + "min" : 12546041, + "max" : 103030763, + "mean" : 49950992.346982, + "stddev" : 3730585.621903, + "N" : 19001, + "percentile" : { + "1.000000" : 38535168, + "5.000000" : 47448064, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 50069504, + "60.000000" : 50593792, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52690944, + "99.000000" : 63700992, + "99.500000" : 67633152, + "99.900000" : 78118912, + "99.950000" : 88604672, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 13867099, + "max" : 103534663, + "mean" : 50572875.763381, + "stddev" : 3742510.420299, + "N" : 19001 + }, + "bw_min" : 2400256, + "bw_max" : 2736128, + "bw_agg" : 24.893307, + "bw_mean" : 2589948.750000, + "bw_dev" : 55880.162646, + "bw_samples" : 60, + "iops_min" : 586, + "iops_max" : 668, + "iops_mean" : 632.300000, + "iops_stddev" : 13.628609, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.382606, + "sys_cpu" : 39.917490, + "ctx" : 20289, + "majf" : 0, + "minf" : 32784, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.836851, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994729, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.242093, + "50" : 49.339508, + "100" : 50.402610, + "250" : 0.015789, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793783884711, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80069263360, + "io_kbytes" : 78192640, + "bw_bytes" : 2663648149, + "bw" : 2601218, + "iops" : 635.063207, + "runtime" : 30060, + "total_ios" : 19090, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 176739, + "max" : 2202046, + "mean" : 570858.532740, + "stddev" : 181218.532241, + "N" : 19090 + }, + "clat_ns" : { + "min" : 12925941, + "max" : 107021448, + "mean" : 49768920.766265, + "stddev" : 3550589.437130, + "N" : 19090, + "percentile" : { + "1.000000" : 34865152, + "5.000000" : 47448064, + "10.000000" : 47972352, + "20.000000" : 49020928, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 50069504, + "60.000000" : 50593792, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 53739520, + "99.500000" : 56885248, + "99.900000" : 82313216, + "99.950000" : 92798976, + "99.990000" : 104333312 + } + }, + "lat_ns" : { + "min" : 14306899, + "max" : 107523247, + "mean" : 50339779.299005, + "stddev" : 3553990.457029, + "N" : 19090 + }, + "bw_min" : 2318336, + "bw_max" : 2760704, + "bw_agg" : 25.010135, + "bw_mean" : 2602103.216667, + "bw_dev" : 63853.547343, + "bw_samples" : 60, + "iops_min" : 566, + "iops_max" : 674, + "iops_mean" : 635.266667, + "iops_stddev" : 15.596465, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30059, + "usr_cpu" : 0.405868, + "sys_cpu" : 39.429123, + "ctx" : 18611, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.837611, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994753, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.282871, + "50" : 50.026192, + "100" : 49.664746, + "250" : 0.026192, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793783884745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 78949384192, + "io_kbytes" : 77099008, + "bw_bytes" : 2629892877, + "bw" : 2568254, + "iops" : 627.015323, + "runtime" : 30020, + "total_ios" : 18823, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 189540, + "max" : 1111598, + "mean" : 582898.864102, + "stddev" : 117544.131711, + "N" : 18823 + }, + "clat_ns" : { + "min" : 2670126, + "max" : 51446462, + "mean" : 24930239.237794, + "stddev" : 2370854.838085, + "N" : 18823, + "percentile" : { + "1.000000" : 20840448, + "5.000000" : 23199744, + "10.000000" : 23724032, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25559040, + "90.000000" : 26083328, + "95.000000" : 26607616, + "99.000000" : 34340864, + "99.500000" : 36438016, + "99.900000" : 44826624, + "99.950000" : 47448064, + "99.990000" : 50069504 + } + }, + "lat_ns" : { + "min" : 3235236, + "max" : 52174771, + "mean" : 25513138.101897, + "stddev" : 2368886.408983, + "N" : 18823 + }, + "bw_min" : 2392064, + "bw_max" : 2662400, + "bw_agg" : 25.001811, + "bw_mean" : 2573591.101695, + "bw_dev" : 58148.114933, + "bw_samples" : 59, + "iops_min" : 584, + "iops_max" : 650, + "iops_mean" : 628.338983, + "iops_stddev" : 14.128243, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.347413, + "sys_cpu" : 31.993071, + "ctx" : 18673, + "majf" : 0, + "minf" : 16, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.920310, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994683, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.100940, + "10" : 0.260320, + "20" : 0.488764, + "50" : 99.139351, + "100" : 0.010625, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793783884745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79213625344, + "io_kbytes" : 77357056, + "bw_bytes" : 2638519264, + "bw" : 2576678, + "iops" : 629.072014, + "runtime" : 30022, + "total_ios" : 18886, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 198210, + "max" : 1113908, + "mean" : 621412.636503, + "stddev" : 94388.788205, + "N" : 18886 + }, + "clat_ns" : { + "min" : 2521216, + "max" : 52844450, + "mean" : 24808121.670020, + "stddev" : 1964844.205350, + "N" : 18886, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 23199744, + "10.000000" : 23724032, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25559040, + "90.000000" : 26083328, + "95.000000" : 26345472, + "99.000000" : 31326208, + "99.500000" : 34340864, + "99.900000" : 40632320, + "99.950000" : 45350912, + "99.990000" : 50593792 + } + }, + "lat_ns" : { + "min" : 3141156, + "max" : 53121590, + "mean" : 25429534.306523, + "stddev" : 1962909.787179, + "N" : 18886 + }, + "bw_min" : 2441216, + "bw_max" : 2670592, + "bw_agg" : 25.061159, + "bw_mean" : 2579700.118644, + "bw_dev" : 46964.056501, + "bw_samples" : 59, + "iops_min" : 596, + "iops_max" : 652, + "iops_mean" : 629.796610, + "iops_stddev" : 11.481289, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30021, + "usr_cpu" : 9.536658, + "sys_cpu" : 34.012858, + "ctx" : 18717, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.920576, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994701, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.074129, + "10" : 0.248862, + "20" : 0.513608, + "50" : 99.147517, + "100" : 0.015885, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793783884745, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79234596864, + "io_kbytes" : 77377536, + "bw_bytes" : 2639305714, + "bw" : 2577446, + "iops" : 629.259518, + "runtime" : 30021, + "total_ios" : 18891, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 187870, + "max" : 1026328, + "mean" : 594224.008999, + "stddev" : 104150.737890, + "N" : 18891 + }, + "clat_ns" : { + "min" : 2356526, + "max" : 49990074, + "mean" : 24827398.983431, + "stddev" : 2024837.006713, + "N" : 18891, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 23199744, + "10.000000" : 23724032, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25559040, + "90.000000" : 25821184, + "95.000000" : 26345472, + "99.000000" : 32374784, + "99.500000" : 34865152, + "99.900000" : 43778048, + "99.950000" : 45875200, + "99.990000" : 50069504 + } + }, + "lat_ns" : { + "min" : 2927845, + "max" : 50668253, + "mean" : 25421622.992430, + "stddev" : 2022157.546837, + "N" : 18891 + }, + "bw_min" : 2490368, + "bw_max" : 2695168, + "bw_agg" : 25.067910, + "bw_mean" : 2580395.186441, + "bw_dev" : 40295.893545, + "bw_samples" : 59, + "iops_min" : 608, + "iops_max" : 658, + "iops_mean" : 629.966102, + "iops_stddev" : 9.864541, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.140573, + "sys_cpu" : 33.041306, + "ctx" : 18747, + "majf" : 0, + "minf" : 17, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.920597, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994703, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.068816, + "10" : 0.264676, + "20" : 0.418189, + "50" : 99.248319, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793783884746, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79054241792, + "io_kbytes" : 77201408, + "bw_bytes" : 2633210372, + "bw" : 2571494, + "iops" : 627.806275, + "runtime" : 30022, + "total_ios" : 18848, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 187310, + "max" : 1145239, + "mean" : 609323.489389, + "stddev" : 121919.319416, + "N" : 18848 + }, + "clat_ns" : { + "min" : 3108605, + "max" : 50023215, + "mean" : 24871344.362107, + "stddev" : 1538511.819270, + "N" : 18848, + "percentile" : { + "1.000000" : 22413312, + "5.000000" : 23461888, + "10.000000" : 23724032, + "20.000000" : 23986176, + "30.000000" : 24510464, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 25034752, + "70.000000" : 25296896, + "80.000000" : 25559040, + "90.000000" : 25821184, + "95.000000" : 26345472, + "99.000000" : 31064064, + "99.500000" : 33161216, + "99.900000" : 38010880, + "99.950000" : 40632320, + "99.990000" : 46923776 + } + }, + "lat_ns" : { + "min" : 3623234, + "max" : 50496534, + "mean" : 25480667.851496, + "stddev" : 1533774.951720, + "N" : 18848 + }, + "bw_min" : 2392064, + "bw_max" : 2662400, + "bw_agg" : 25.020677, + "bw_mean" : 2575533.305085, + "bw_dev" : 44313.285528, + "bw_samples" : 59, + "iops_min" : 584, + "iops_max" : 650, + "iops_mean" : 628.779661, + "iops_stddev" : 10.821543, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30021, + "usr_cpu" : 9.113620, + "sys_cpu" : 33.976217, + "ctx" : 18677, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.920416, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994690, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.021222, + "10" : 0.106112, + "20" : 0.127334, + "50" : 99.740025, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 615712, + "write_ios" : 604733, + "read_sectors" : 156400128, + "write_sectors" : 153315328, + "read_merges" : 3588, + "write_merges" : 5854, + "read_ticks" : 29735371, + "write_ticks" : 14622260, + "in_queue" : 44357630, + "util" : 99.672963 + }, + { + "name" : "nvme2n1", + "read_ios" : 609074, + "write_ios" : 607631, + "read_sectors" : 155165936, + "write_sectors" : 153753088, + "read_merges" : 2958, + "write_merges" : 5863, + "read_ticks" : 29666643, + "write_ticks" : 14641470, + "in_queue" : 44308112, + "util" : 99.712864 + }, + { + "name" : "nvme3n1", + "read_ios" : 609812, + "write_ios" : 607869, + "read_sectors" : 154752000, + "write_sectors" : 153808896, + "read_merges" : 3547, + "write_merges" : 7040, + "read_ticks" : 29790256, + "write_ticks" : 14647481, + "in_queue" : 44437737, + "util" : 99.752872 + }, + { + "name" : "nvme4n1", + "read_ios" : 610962, + "write_ios" : 605352, + "read_sectors" : 155494912, + "write_sectors" : 153470720, + "read_merges" : 4168, + "write_merges" : 5857, + "read_ticks" : 29707937, + "write_ticks" : 14625936, + "in_queue" : 44333874, + "util" : 99.832877 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_2.json new file mode 100644 index 0000000..6608075 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_2.json @@ -0,0 +1,2085 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784036, + "timestamp_ms" : 1793784036808, + "time" : "Wed Nov 4 09:20:36 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784006667, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 81012981760, + "io_kbytes" : 79114240, + "bw_bytes" : 2694952987, + "bw" : 2631790, + "iops" : 642.526862, + "runtime" : 30061, + "total_ios" : 19315, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158200, + "max" : 1860357, + "mean" : 582826.683614, + "stddev" : 160967.034354, + "N" : 19315 + }, + "clat_ns" : { + "min" : 7971907, + "max" : 107507398, + "mean" : 49174397.925084, + "stddev" : 4178313.496293, + "N" : 19315, + "percentile" : { + "1.000000" : 26869760, + "5.000000" : 46399488, + "10.000000" : 47448064, + "20.000000" : 47972352, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 52166656, + "99.000000" : 57933824, + "99.500000" : 63176704, + "99.900000" : 79167488, + "99.950000" : 93847552, + "99.990000" : 105381888 + } + }, + "lat_ns" : { + "min" : 8226937, + "max" : 107966007, + "mean" : 49757224.608698, + "stddev" : 4182989.108609, + "N" : 19315 + }, + "bw_min" : 2433024, + "bw_max" : 2752512, + "bw_agg" : 25.101170, + "bw_mean" : 2632214.600000, + "bw_dev" : 49747.316731, + "bw_samples" : 60, + "iops_min" : 594, + "iops_max" : 672, + "iops_mean" : 642.533333, + "iops_stddev" : 12.206509, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30060, + "usr_cpu" : 0.419162, + "sys_cpu" : 42.085828, + "ctx" : 17812, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839503, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994815, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.056951, + "20" : 0.403831, + "50" : 63.499871, + "100" : 36.008284, + "250" : 0.031064, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784006667, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80459333632, + "io_kbytes" : 78573568, + "bw_bytes" : 2676713584, + "bw" : 2613978, + "iops" : 638.178249, + "runtime" : 30059, + "total_ios" : 19183, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 167070, + "max" : 2006867, + "mean" : 508593.345149, + "stddev" : 194451.208677, + "N" : 19183 + }, + "clat_ns" : { + "min" : 11939151, + "max" : 105521941, + "mean" : 49587472.024032, + "stddev" : 3731715.619188, + "N" : 19183, + "percentile" : { + "1.000000" : 39583744, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 64749568, + "99.500000" : 66322432, + "99.900000" : 76021760, + "99.950000" : 89653248, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 13370709, + "max" : 105969310, + "mean" : 50096065.369181, + "stddev" : 3732844.743904, + "N" : 19183 + }, + "bw_min" : 2400256, + "bw_max" : 2768896, + "bw_agg" : 24.929205, + "bw_mean" : 2614181.850000, + "bw_dev" : 61142.371685, + "bw_samples" : 60, + "iops_min" : 586, + "iops_max" : 676, + "iops_mean" : 638.133333, + "iops_stddev" : 14.888816, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30058, + "usr_cpu" : 0.352652, + "sys_cpu" : 35.221904, + "ctx" : 19356, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838399, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994779, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.192879, + "50" : 62.305166, + "100" : 37.486316, + "250" : 0.015639, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784006667, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80752934912, + "io_kbytes" : 78860288, + "bw_bytes" : 2686481084, + "bw" : 2623516, + "iops" : 640.507003, + "runtime" : 30059, + "total_ios" : 19253, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 164069, + "max" : 10897382, + "mean" : 534904.638758, + "stddev" : 190729.521354, + "N" : 19253 + }, + "clat_ns" : { + "min" : 12814280, + "max" : 106717929, + "mean" : 49378125.637822, + "stddev" : 3675030.356007, + "N" : 19253, + "percentile" : { + "1.000000" : 33161216, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 56360960, + "99.500000" : 62128128, + "99.900000" : 77070336, + "99.950000" : 92798976, + "99.990000" : 105381888 + } + }, + "lat_ns" : { + "min" : 14115728, + "max" : 107294418, + "mean" : 49913030.276580, + "stddev" : 3666935.700366, + "N" : 19253 + }, + "bw_min" : 2441216, + "bw_max" : 2752512, + "bw_agg" : 25.020390, + "bw_mean" : 2623743.533333, + "bw_dev" : 54865.806271, + "bw_samples" : 60, + "iops_min" : 596, + "iops_max" : 672, + "iops_mean" : 640.466667, + "iops_stddev" : 13.395505, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30058, + "usr_cpu" : 0.282787, + "sys_cpu" : 38.468960, + "ctx" : 18253, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838986, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994798, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.306446, + "50" : 62.099413, + "100" : 37.568171, + "250" : 0.025970, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784006667, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80572579840, + "io_kbytes" : 78684160, + "bw_bytes" : 2680570225, + "bw" : 2617744, + "iops" : 639.097744, + "runtime" : 30058, + "total_ios" : 19210, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 150039, + "max" : 1954207, + "mean" : 564992.895888, + "stddev" : 163868.083645, + "N" : 19210 + }, + "clat_ns" : { + "min" : 12296030, + "max" : 102857095, + "mean" : 49457907.181780, + "stddev" : 3208663.432747, + "N" : 19210, + "percentile" : { + "1.000000" : 42729472, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 51642368, + "99.000000" : 58982400, + "99.500000" : 63176704, + "99.900000" : 76021760, + "99.950000" : 89653248, + "99.990000" : 102236160 + } + }, + "lat_ns" : { + "min" : 13592648, + "max" : 103581294, + "mean" : 50022900.077668, + "stddev" : 3205203.153165, + "N" : 19210 + }, + "bw_min" : 2433024, + "bw_max" : 2768896, + "bw_agg" : 24.964412, + "bw_mean" : 2617873.966667, + "bw_dev" : 54810.737573, + "bw_samples" : 60, + "iops_min" : 594, + "iops_max" : 676, + "iops_mean" : 639.033333, + "iops_stddev" : 13.380946, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.339355, + "sys_cpu" : 40.729281, + "ctx" : 17975, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838626, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994786, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.203019, + "50" : 64.320666, + "100" : 35.465903, + "250" : 0.010411, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784006719, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80002154496, + "io_kbytes" : 78127104, + "bw_bytes" : 2665050617, + "bw" : 2602588, + "iops" : 635.397582, + "runtime" : 30019, + "total_ios" : 19074, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 189280, + "max" : 1484237, + "mean" : 573385.220929, + "stddev" : 77235.922735, + "N" : 19074 + }, + "clat_ns" : { + "min" : 2532166, + "max" : 47874664, + "mean" : 24603496.128657, + "stddev" : 1781645.675772, + "N" : 19074, + "percentile" : { + "1.000000" : 21889024, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 32112640, + "99.500000" : 33816576, + "99.900000" : 36962304, + "99.950000" : 41156608, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 2968836, + "max" : 48388513, + "mean" : 25176881.349586, + "stddev" : 1779103.061788, + "N" : 19074 + }, + "bw_min" : 2482176, + "bw_max" : 2711552, + "bw_agg" : 25.007729, + "bw_mean" : 2604020.542373, + "bw_dev" : 45353.744714, + "bw_samples" : 59, + "iops_min" : 606, + "iops_max" : 662, + "iops_mean" : 635.661017, + "iops_stddev" : 11.068143, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30018, + "usr_cpu" : 9.570924, + "sys_cpu" : 33.343327, + "ctx" : 18951, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921359, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994753, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.052427, + "10" : 0.157282, + "20" : 0.277865, + "50" : 99.512425, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784006701, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80094429184, + "io_kbytes" : 78217216, + "bw_bytes" : 2667946743, + "bw" : 2605416, + "iops" : 636.088072, + "runtime" : 30021, + "total_ios" : 19096, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 201699, + "max" : 1189478, + "mean" : 599896.541370, + "stddev" : 97408.874383, + "N" : 19096 + }, + "clat_ns" : { + "min" : 2087047, + "max" : 43789640, + "mean" : 24549335.214966, + "stddev" : 1975470.870435, + "N" : 19096, + "percentile" : { + "1.000000" : 20054016, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 31064064, + "99.500000" : 33816576, + "99.900000" : 39583744, + "99.950000" : 40632320, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 2570906, + "max" : 44358029, + "mean" : 25149231.756336, + "stddev" : 1978575.524610, + "N" : 19096 + }, + "bw_min" : 2465792, + "bw_max" : 2706139, + "bw_agg" : 25.049043, + "bw_mean" : 2608322.864407, + "bw_dev" : 41309.538649, + "bw_samples" : 59, + "iops_min" : 602, + "iops_max" : 660, + "iops_mean" : 636.711864, + "iops_stddev" : 10.073952, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.220520, + "sys_cpu" : 33.577615, + "ctx" : 18914, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921450, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994759, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.094261, + "10" : 0.303729, + "20" : 0.581274, + "50" : 99.020737, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784006701, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79859548160, + "io_kbytes" : 77987840, + "bw_bytes" : 2660034246, + "bw" : 2597689, + "iops" : 634.201586, + "runtime" : 30022, + "total_ios" : 19040, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 194510, + "max" : 1256798, + "mean" : 605761.013183, + "stddev" : 101897.558677, + "N" : 19040 + }, + "clat_ns" : { + "min" : 2221847, + "max" : 49880840, + "mean" : 24618176.329254, + "stddev" : 1759891.141358, + "N" : 19040, + "percentile" : { + "1.000000" : 21889024, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 31326208, + "99.500000" : 33816576, + "99.900000" : 39059456, + "99.950000" : 42205184, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 2486156, + "max" : 50372980, + "mean" : 25223937.342437, + "stddev" : 1756263.920906, + "N" : 19040 + }, + "bw_min" : 2482176, + "bw_max" : 2670592, + "bw_agg" : 24.992555, + "bw_mean" : 2602440.542373, + "bw_dev" : 39307.260573, + "bw_samples" : 59, + "iops_min" : 606, + "iops_max" : 652, + "iops_mean" : 635.288136, + "iops_stddev" : 9.568358, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30021, + "usr_cpu" : 9.556644, + "sys_cpu" : 34.385930, + "ctx" : 18855, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921218, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994744, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.063025, + "10" : 0.157563, + "20" : 0.278361, + "50" : 99.501050, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784006701, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80161538048, + "io_kbytes" : 78282752, + "bw_bytes" : 2670182140, + "bw" : 2607599, + "iops" : 636.621032, + "runtime" : 30021, + "total_ios" : 19112, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 195070, + "max" : 1057218, + "mean" : 595993.510674, + "stddev" : 96158.393506, + "N" : 19112 + }, + "clat_ns" : { + "min" : 2029247, + "max" : 52232286, + "mean" : 24532112.384784, + "stddev" : 1821818.092710, + "N" : 19112, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 28442624, + "99.500000" : 32636928, + "99.900000" : 39583744, + "99.950000" : 45350912, + "99.990000" : 50593792 + } + }, + "lat_ns" : { + "min" : 2537896, + "max" : 52756956, + "mean" : 25128105.895459, + "stddev" : 1820274.051121, + "N" : 19112 + }, + "bw_min" : 2523136, + "bw_max" : 2711552, + "bw_agg" : 25.063294, + "bw_mean" : 2609806.677966, + "bw_dev" : 37746.966476, + "bw_samples" : 59, + "iops_min" : 616, + "iops_max" : 662, + "iops_mean" : 637.084746, + "iops_stddev" : 9.272295, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.403731, + "sys_cpu" : 33.694204, + "ctx" : 19010, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921515, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994764, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.083717, + "10" : 0.224990, + "20" : 0.476141, + "50" : 99.204688, + "100" : 0.010465, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 617772, + "write_ios" : 609855, + "read_sectors" : 157370952, + "write_sectors" : 155214592, + "read_merges" : 3605, + "write_merges" : 2368, + "read_ticks" : 29648498, + "write_ticks" : 14558957, + "in_queue" : 44207455, + "util" : 99.716279 + }, + { + "name" : "nvme2n1", + "read_ios" : 613516, + "write_ios" : 613511, + "read_sectors" : 156296960, + "write_sectors" : 155540992, + "read_merges" : 4180, + "write_merges" : 5941, + "read_ticks" : 29723921, + "write_ticks" : 14616756, + "in_queue" : 44340677, + "util" : 99.742922 + }, + { + "name" : "nvme3n1", + "read_ios" : 615242, + "write_ios" : 610585, + "read_sectors" : 156889344, + "write_sectors" : 155098112, + "read_merges" : 4197, + "write_merges" : 4734, + "read_ticks" : 29667514, + "write_ticks" : 14585442, + "in_queue" : 44252956, + "util" : 99.762907 + }, + { + "name" : "nvme4n1", + "read_ios" : 614371, + "write_ios" : 613878, + "read_sectors" : 156513536, + "write_sectors" : 155631360, + "read_merges" : 4787, + "write_merges" : 3562, + "read_ticks" : 29678480, + "write_ticks" : 14620144, + "in_queue" : 44298625, + "util" : 99.872982 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_3.json new file mode 100644 index 0000000..1cd2d70 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_3.json @@ -0,0 +1,2085 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784158, + "timestamp_ms" : 1793784158799, + "time" : "Wed Nov 4 09:22:38 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784128652, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80690020352, + "io_kbytes" : 78798848, + "bw_bytes" : 2684209452, + "bw" : 2621298, + "iops" : 639.965404, + "runtime" : 30061, + "total_ios" : 19238, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 153570, + "max" : 2607476, + "mean" : 565470.251118, + "stddev" : 158617.992941, + "N" : 19238 + }, + "clat_ns" : { + "min" : 8051487, + "max" : 110667255, + "mean" : 49390311.718266, + "stddev" : 3808527.494999, + "N" : 19238, + "percentile" : { + "1.000000" : 38535168, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 47972352, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 49545216, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 52166656, + "99.000000" : 62128128, + "99.500000" : 64749568, + "99.900000" : 80216064, + "99.950000" : 93847552, + "99.990000" : 107479040 + } + }, + "lat_ns" : { + "min" : 8312206, + "max" : 111685543, + "mean" : 49955781.969383, + "stddev" : 3809230.241106, + "N" : 19238 + }, + "bw_min" : 2469045, + "bw_max" : 2752512, + "bw_agg" : 25.050724, + "bw_mean" : 2621000.833333, + "bw_dev" : 59084.716705, + "bw_samples" : 60, + "iops_min" : 602, + "iops_max" : 672, + "iops_mean" : 639.700000, + "iops_stddev" : 14.454253, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30060, + "usr_cpu" : 0.432468, + "sys_cpu" : 41.034597, + "ctx" : 17910, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838861, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994794, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.062377, + "20" : 0.244308, + "50" : 65.162699, + "100" : 34.494230, + "250" : 0.036386, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784128653, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80144760832, + "io_kbytes" : 78266368, + "bw_bytes" : 2665982330, + "bw" : 2603498, + "iops" : 635.619719, + "runtime" : 30062, + "total_ios" : 19108, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 158680, + "max" : 1946207, + "mean" : 567868.594149, + "stddev" : 165647.626406, + "N" : 19108 + }, + "clat_ns" : { + "min" : 8119487, + "max" : 107779320, + "mean" : 49728400.095929, + "stddev" : 3727913.921870, + "N" : 19108, + "percentile" : { + "1.000000" : 42729472, + "5.000000" : 47448064, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 63176704, + "99.500000" : 66322432, + "99.900000" : 78118912, + "99.950000" : 93847552, + "99.990000" : 106430464 + } + }, + "lat_ns" : { + "min" : 8437006, + "max" : 108291259, + "mean" : 50296268.690077, + "stddev" : 3729955.930160, + "N" : 19108 + }, + "bw_min" : 2436343, + "bw_max" : 2711552, + "bw_agg" : 24.881189, + "bw_mean" : 2603262.416667, + "bw_dev" : 53034.320466, + "bw_samples" : 60, + "iops_min" : 594, + "iops_max" : 662, + "iops_mean" : 635.366667, + "iops_stddev" : 12.990174, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30061, + "usr_cpu" : 0.382555, + "sys_cpu" : 40.866904, + "ctx" : 17910, + "majf" : 0, + "minf" : 32777, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.837764, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994758, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.130835, + "20" : 0.177936, + "50" : 56.892401, + "100" : 42.772661, + "250" : 0.026167, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784128653, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80329310208, + "io_kbytes" : 78446592, + "bw_bytes" : 2672565798, + "bw" : 2609927, + "iops" : 637.189340, + "runtime" : 30057, + "total_ios" : 19152, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 169110, + "max" : 2098997, + "mean" : 578934.111163, + "stddev" : 149852.059743, + "N" : 19152 + }, + "clat_ns" : { + "min" : 12054640, + "max" : 103578187, + "mean" : 49594856.629438, + "stddev" : 3430180.213893, + "N" : 19152, + "percentile" : { + "1.000000" : 41680896, + "5.000000" : 46923776, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 61079552, + "99.500000" : 64749568, + "99.900000" : 76021760, + "99.950000" : 90701824, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 13517878, + "max" : 104243206, + "mean" : 50173790.740602, + "stddev" : 3424388.619473, + "N" : 19152 + }, + "bw_min" : 2419992, + "bw_max" : 2727936, + "bw_agg" : 24.938526, + "bw_mean" : 2609261.433333, + "bw_dev" : 52246.490307, + "bw_samples" : 60, + "iops_min" : 590, + "iops_max" : 666, + "iops_mean" : 636.833333, + "iops_stddev" : 12.762719, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30056, + "usr_cpu" : 0.369311, + "sys_cpu" : 42.274421, + "ctx" : 17347, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838137, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994770, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.203634, + "50" : 60.902256, + "100" : 38.878446, + "250" : 0.015664, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784128653, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80916512768, + "io_kbytes" : 79020032, + "bw_bytes" : 2692012534, + "bw" : 2628918, + "iops" : 641.825803, + "runtime" : 30058, + "total_ios" : 19292, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 161719, + "max" : 9277655, + "mean" : 559128.980873, + "stddev" : 170609.108428, + "N" : 19292 + }, + "clat_ns" : { + "min" : 11486391, + "max" : 104084776, + "mean" : 49252373.089727, + "stddev" : 3561644.466065, + "N" : 19292, + "percentile" : { + "1.000000" : 36962304, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 47972352, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 49545216, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 52166656, + "99.000000" : 56360960, + "99.500000" : 62128128, + "99.900000" : 77070336, + "99.950000" : 90701824, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 12901079, + "max" : 104673175, + "mean" : 49811502.070599, + "stddev" : 3561640.391662, + "N" : 19292 + }, + "bw_min" : 2493572, + "bw_max" : 2859008, + "bw_agg" : 25.121164, + "bw_mean" : 2628370.366667, + "bw_dev" : 58567.139012, + "bw_samples" : 60, + "iops_min" : 608, + "iops_max" : 698, + "iops_mean" : 641.500000, + "iops_stddev" : 14.330837, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.419204, + "sys_cpu" : 40.762551, + "ctx" : 17991, + "majf" : 0, + "minf" : 32778, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.839312, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994808, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.305826, + "50" : 65.514203, + "100" : 34.164420, + "250" : 0.015550, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784128706, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80438362112, + "io_kbytes" : 78553088, + "bw_bytes" : 2679581668, + "bw" : 2616778, + "iops" : 638.862054, + "runtime" : 30019, + "total_ios" : 19178, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 184519, + "max" : 1121699, + "mean" : 597962.257639, + "stddev" : 85289.939276, + "N" : 19178 + }, + "clat_ns" : { + "min" : 2362477, + "max" : 46773022, + "mean" : 24442047.819011, + "stddev" : 1824178.721590, + "N" : 19178, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 24772608, + "80.000000" : 25034752, + "90.000000" : 25559040, + "95.000000" : 25821184, + "99.000000" : 30015488, + "99.500000" : 33161216, + "99.900000" : 39583744, + "99.950000" : 42205184, + "99.990000" : 45875200 + } + }, + "lat_ns" : { + "min" : 2867516, + "max" : 47029942, + "mean" : 25040010.076650, + "stddev" : 1822007.015079, + "N" : 19178 + }, + "bw_min" : 2531328, + "bw_max" : 2711552, + "bw_agg" : 25.081175, + "bw_mean" : 2617059.067797, + "bw_dev" : 36131.880296, + "bw_samples" : 59, + "iops_min" : 618, + "iops_max" : 662, + "iops_mean" : 638.711864, + "iops_stddev" : 8.763267, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30018, + "usr_cpu" : 10.437071, + "sys_cpu" : 34.249450, + "ctx" : 19004, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921785, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994782, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.083429, + "10" : 0.213787, + "20" : 0.438002, + "50" : 99.264783, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784128717, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80182509568, + "io_kbytes" : 78303232, + "bw_bytes" : 2671147630, + "bw" : 2608542, + "iops" : 636.851223, + "runtime" : 30018, + "total_ios" : 19117, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 184320, + "max" : 1050658, + "mean" : 575762.712507, + "stddev" : 77462.468470, + "N" : 19117 + }, + "clat_ns" : { + "min" : 2026577, + "max" : 46212553, + "mean" : 24543783.803997, + "stddev" : 1748043.146357, + "N" : 19117, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 28704768, + "99.500000" : 32636928, + "99.900000" : 38535168, + "99.950000" : 40108032, + "99.990000" : 44302336 + } + }, + "lat_ns" : { + "min" : 2273576, + "max" : 46654222, + "mean" : 25119546.516504, + "stddev" : 1748334.145361, + "N" : 19117 + }, + "bw_min" : 2514944, + "bw_max" : 2678784, + "bw_agg" : 25.000921, + "bw_mean" : 2608685.542373, + "bw_dev" : 37230.745235, + "bw_samples" : 59, + "iops_min" : 614, + "iops_max" : 654, + "iops_mean" : 636.677966, + "iops_stddev" : 9.056224, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30017, + "usr_cpu" : 9.907719, + "sys_cpu" : 33.720891, + "ctx" : 18975, + "majf" : 0, + "minf" : 10, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921536, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994765, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.083695, + "10" : 0.214469, + "20" : 0.345242, + "50" : 99.356594, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784128688, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79939239936, + "io_kbytes" : 78065664, + "bw_bytes" : 2662866087, + "bw" : 2600455, + "iops" : 634.876749, + "runtime" : 30020, + "total_ios" : 19059, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 179899, + "max" : 1055558, + "mean" : 602685.427829, + "stddev" : 99192.980315, + "N" : 19059 + }, + "clat_ns" : { + "min" : 2438526, + "max" : 44355386, + "mean" : 24594761.108453, + "stddev" : 1779742.952091, + "N" : 19059, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 29753344, + "99.500000" : 33161216, + "99.900000" : 39059456, + "99.950000" : 40108032, + "99.990000" : 42729472 + } + }, + "lat_ns" : { + "min" : 2934596, + "max" : 44927615, + "mean" : 25197446.536282, + "stddev" : 1778982.052377, + "N" : 19059 + }, + "bw_min" : 2493572, + "bw_max" : 2706139, + "bw_agg" : 24.932742, + "bw_mean" : 2601571.559322, + "bw_dev" : 36893.871031, + "bw_samples" : 59, + "iops_min" : 608, + "iops_max" : 660, + "iops_mean" : 634.915254, + "iops_stddev" : 8.985214, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.666889, + "sys_cpu" : 33.927382, + "ctx" : 18872, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921297, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994749, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.073456, + "10" : 0.215121, + "20" : 0.398762, + "50" : 99.312661, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784128688, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80207675392, + "io_kbytes" : 78327808, + "bw_bytes" : 2671718976, + "bw" : 2609100, + "iops" : 636.987442, + "runtime" : 30021, + "total_ios" : 19123, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 187410, + "max" : 9934853, + "mean" : 571227.687078, + "stddev" : 115468.851939, + "N" : 19123 + }, + "clat_ns" : { + "min" : 2616385, + "max" : 48930769, + "mean" : 24542252.930137, + "stddev" : 1837459.833900, + "N" : 19123, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30539776, + "99.500000" : 34340864, + "99.900000" : 42729472, + "99.950000" : 44302336, + "99.990000" : 47972352 + } + }, + "lat_ns" : { + "min" : 3101405, + "max" : 49451328, + "mean" : 25113480.617215, + "stddev" : 1837407.348516, + "N" : 19123 + }, + "bw_min" : 2485397, + "bw_max" : 2719744, + "bw_agg" : 25.009939, + "bw_mean" : 2609626.440678, + "bw_dev" : 42484.859042, + "bw_samples" : 59, + "iops_min" : 606, + "iops_max" : 664, + "iops_mean" : 636.881356, + "iops_stddev" : 10.413990, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.210526, + "sys_cpu" : 32.784810, + "ctx" : 18992, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 99.921560, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994767, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.057522, + "10" : 0.177796, + "20" : 0.392198, + "50" : 99.372483, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 615135, + "write_ios" : 613108, + "read_sectors" : 156709376, + "write_sectors" : 156039424, + "read_merges" : 4194, + "write_merges" : 3564, + "read_ticks" : 29653698, + "write_ticks" : 14534143, + "in_queue" : 44187841, + "util" : 99.656289 + }, + { + "name" : "nvme2n1", + "read_ios" : 610997, + "write_ios" : 609724, + "read_sectors" : 155654656, + "write_sectors" : 155482880, + "read_merges" : 4161, + "write_merges" : 2379, + "read_ticks" : 29664017, + "write_ticks" : 14510670, + "in_queue" : 44174688, + "util" : 99.699529 + }, + { + "name" : "nvme3n1", + "read_ios" : 611759, + "write_ios" : 610903, + "read_sectors" : 156000256, + "write_sectors" : 155176960, + "read_merges" : 4167, + "write_merges" : 5920, + "read_ticks" : 29626845, + "write_ticks" : 14577960, + "in_queue" : 44204805, + "util" : 99.742862 + }, + { + "name" : "nvme4n1", + "read_ios" : 616862, + "write_ios" : 613024, + "read_sectors" : 157150464, + "write_sectors" : 155716352, + "read_merges" : 4209, + "write_merges" : 4753, + "read_ticks" : 29659137, + "write_ticks" : 14594592, + "in_queue" : 44253729, + "util" : 99.842888 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_1.json new file mode 100644 index 0000000..dda4978 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_1.json @@ -0,0 +1,2165 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793783945, + "timestamp_ms" : 1793783945367, + "time" : "Wed Nov 4 09:19:05 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793783915227, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80337698816, + "io_kbytes" : 78454784, + "bw_bytes" : 2672844888, + "bw" : 2610200, + "iops" : 637.255880, + "runtime" : 30057, + "total_ios" : 19154, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 177500, + "max" : 2245536, + "mean" : 622628.010442, + "stddev" : 183422.980289, + "N" : 19154 + }, + "clat_ns" : { + "min" : 12880841, + "max" : 103025701, + "mean" : 49544190.360917, + "stddev" : 3710049.524242, + "N" : 19154, + "percentile" : { + "1.000000" : 37486592, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 60555264, + "99.500000" : 64225280, + "99.900000" : 82313216, + "99.950000" : 88604672, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 14375189, + "max" : 103707280, + "mean" : 50166818.371358, + "stddev" : 3713848.033400, + "N" : 19154 + }, + "bw_min" : 2424832, + "bw_max" : 2785280, + "bw_agg" : 24.968324, + "bw_mean" : 2610753.316667, + "bw_dev" : 53170.487829, + "bw_samples" : 60, + "iops_min" : 592, + "iops_max" : 680, + "iops_mean" : 637.366667, + "iops_stddev" : 12.984954, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30056, + "usr_cpu" : 0.375965, + "sys_cpu" : 43.102875, + "ctx" : 18235, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838154, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994771, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.271484, + "50" : 60.859351, + "100" : 38.858724, + "250" : 0.010442, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793783915227, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80371253248, + "io_kbytes" : 78487552, + "bw_bytes" : 2673872288, + "bw" : 2611203, + "iops" : 637.500832, + "runtime" : 30058, + "total_ios" : 19162, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 161210, + "max" : 2249996, + "mean" : 609012.131354, + "stddev" : 175975.850089, + "N" : 19162 + }, + "clat_ns" : { + "min" : 12887780, + "max" : 103578411, + "mean" : 49539122.874282, + "stddev" : 4053994.201936, + "N" : 19162, + "percentile" : { + "1.000000" : 32899072, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 63700992, + "99.500000" : 65798144, + "99.900000" : 82313216, + "99.950000" : 90701824, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 14308258, + "max" : 104130960, + "mean" : 50148135.005636, + "stddev" : 4058340.294873, + "N" : 19162 + }, + "bw_min" : 2310144, + "bw_max" : 2744320, + "bw_agg" : 24.978720, + "bw_mean" : 2611840.150000, + "bw_dev" : 77825.898822, + "bw_samples" : 60, + "iops_min" : 564, + "iops_max" : 670, + "iops_mean" : 637.633333, + "iops_stddev" : 18.978995, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.362644, + "sys_cpu" : 42.762085, + "ctx" : 17870, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838221, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994773, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.333994, + "50" : 62.002922, + "100" : 37.642209, + "250" : 0.020875, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793783915227, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80639688704, + "io_kbytes" : 78749696, + "bw_bytes" : 2683249216, + "bw" : 2620360, + "iops" : 639.736466, + "runtime" : 30053, + "total_ios" : 19226, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 173970, + "max" : 1976247, + "mean" : 565443.289868, + "stddev" : 159949.861924, + "N" : 19226 + }, + "clat_ns" : { + "min" : 12441071, + "max" : 95954092, + "mean" : 49409172.432019, + "stddev" : 3270792.471036, + "N" : 19226, + "percentile" : { + "1.000000" : 40108032, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 52166656, + "99.000000" : 54788096, + "99.500000" : 62128128, + "99.900000" : 73924608, + "99.950000" : 81264640, + "99.990000" : 93847552 + } + }, + "lat_ns" : { + "min" : 13770919, + "max" : 96456361, + "mean" : 49974615.721887, + "stddev" : 3269463.230538, + "N" : 19226 + }, + "bw_min" : 2408448, + "bw_max" : 2768896, + "bw_agg" : 25.062326, + "bw_mean" : 2620582.083333, + "bw_dev" : 56768.521565, + "bw_samples" : 60, + "iops_min" : 588, + "iops_max" : 676, + "iops_mean" : 639.766667, + "iops_stddev" : 13.856855, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30052, + "usr_cpu" : 0.385998, + "sys_cpu" : 40.672834, + "ctx" : 17988, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838760, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994791, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.244461, + "50" : 62.425882, + "100" : 37.329658, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793783915227, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80488693760, + "io_kbytes" : 78602240, + "bw_bytes" : 2677957604, + "bw" : 2615192, + "iops" : 638.474847, + "runtime" : 30056, + "total_ios" : 19190, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 161640, + "max" : 2184487, + "mean" : 596370.927983, + "stddev" : 197723.178355, + "N" : 19190 + }, + "clat_ns" : { + "min" : 12745211, + "max" : 100930765, + "mean" : 49476182.760240, + "stddev" : 3223019.151170, + "N" : 19190, + "percentile" : { + "1.000000" : 42729472, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51118080, + "95.000000" : 52166656, + "99.000000" : 57409536, + "99.500000" : 63700992, + "99.900000" : 74973184, + "99.950000" : 88604672, + "99.990000" : 100139008 + } + }, + "lat_ns" : { + "min" : 14216328, + "max" : 101630403, + "mean" : 50072553.688223, + "stddev" : 3229025.549126, + "N" : 19190 + }, + "bw_min" : 2424832, + "bw_max" : 2908160, + "bw_agg" : 25.015330, + "bw_mean" : 2615668.516667, + "bw_dev" : 59302.421409, + "bw_samples" : 60, + "iops_min" : 592, + "iops_max" : 710, + "iops_mean" : 638.566667, + "iops_stddev" : 14.483616, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30055, + "usr_cpu" : 0.415904, + "sys_cpu" : 40.951589, + "ctx" : 18867, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838458, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994781, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.229286, + "50" : 62.256384, + "100" : 37.503908, + "250" : 0.010422, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793783915262, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80220258304, + "io_kbytes" : 78340096, + "bw_bytes" : 2672227125, + "bw" : 2609596, + "iops" : 637.108594, + "runtime" : 30020, + "total_ios" : 19126, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 180140, + "max" : 1324698, + "mean" : 559434.722681, + "stddev" : 119330.802901, + "N" : 19126 + }, + "clat_ns" : { + "min" : 2200706, + "max" : 48187996, + "mean" : 24548528.738942, + "stddev" : 2002857.919386, + "N" : 19126, + "percentile" : { + "1.000000" : 20316160, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 31326208, + "99.500000" : 34340864, + "99.900000" : 42205184, + "99.950000" : 44826624, + "99.990000" : 47972352 + } + }, + "lat_ns" : { + "min" : 2615516, + "max" : 48710235, + "mean" : 25107963.461623, + "stddev" : 2004094.993062, + "N" : 19126 + }, + "bw_min" : 2482176, + "bw_max" : 2716985, + "bw_agg" : 25.081257, + "bw_mean" : 2612003.711864, + "bw_dev" : 39108.617526, + "bw_samples" : 59, + "iops_min" : 606, + "iops_max" : 663, + "iops_mean" : 637.677966, + "iops_stddev" : 9.551026, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4779, + "lat_ns" : { + "min" : 2907166, + "max" : 13463150095715, + "mean" : 2841693845.697845, + "stddev" : 194749961461.772369, + "N" : 4779, + "percentile" : { + "1.000000" : 20578304, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 31064064, + "99.500000" : 34340864, + "99.900000" : 45875200, + "99.950000" : 47972352, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.370732, + "sys_cpu" : 31.816516, + "ctx" : 19007, + "majf" : 0, + "minf" : 16, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.903273, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994768, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.094113, + "10" : 0.266653, + "20" : 0.517620, + "50" : 99.121615, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793783915261, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79846965248, + "io_kbytes" : 77975552, + "bw_bytes" : 2659703715, + "bw" : 2597366, + "iops" : 634.122781, + "runtime" : 30021, + "total_ios" : 19037, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 184839, + "max" : 1169529, + "mean" : 592544.924305, + "stddev" : 101514.878160, + "N" : 19037 + }, + "clat_ns" : { + "min" : 2506436, + "max" : 50837503, + "mean" : 24633464.178442, + "stddev" : 2237377.809056, + "N" : 19037, + "percentile" : { + "1.000000" : 17956864, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 32636928, + "99.500000" : 34865152, + "99.900000" : 39583744, + "99.950000" : 42205184, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 2985286, + "max" : 51295562, + "mean" : 25226009.102747, + "stddev" : 2240278.965154, + "N" : 19037 + }, + "bw_min" : 2498560, + "bw_max" : 2703360, + "bw_agg" : 24.967883, + "bw_mean" : 2600196.966102, + "bw_dev" : 44120.347463, + "bw_samples" : 59, + "iops_min" : 610, + "iops_max" : 660, + "iops_mean" : 634.796610, + "iops_stddev" : 10.760367, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4757, + "lat_ns" : { + "min" : 3066965, + "max" : 13463149806485, + "mean" : 2854848659.327106, + "stddev" : 195199772220.801453, + "N" : 4757, + "percentile" : { + "1.000000" : 19791872, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24772608, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26345472, + "99.000000" : 33161216, + "99.500000" : 35389440, + "99.900000" : 39583744, + "99.950000" : 39583744, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.010660, + "sys_cpu" : 33.237841, + "ctx" : 18889, + "majf" : 0, + "minf" : 13, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.904134, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994743, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.131323, + "10" : 0.346693, + "20" : 0.829963, + "50" : 98.686768, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793783915261, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80002154496, + "io_kbytes" : 78127104, + "bw_bytes" : 2664873072, + "bw" : 2602415, + "iops" : 635.355251, + "runtime" : 30021, + "total_ios" : 19074, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 185260, + "max" : 1203349, + "mean" : 575457.697599, + "stddev" : 114500.436097, + "N" : 19074 + }, + "clat_ns" : { + "min" : 2785966, + "max" : 51062471, + "mean" : 24601421.201531, + "stddev" : 1721281.420588, + "N" : 19074, + "percentile" : { + "1.000000" : 21889024, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30015488, + "99.500000" : 33161216, + "99.900000" : 41156608, + "99.950000" : 44826624, + "99.990000" : 49545216 + } + }, + "lat_ns" : { + "min" : 3143595, + "max" : 51733160, + "mean" : 25176878.899130, + "stddev" : 1721173.885099, + "N" : 19074 + }, + "bw_min" : 2457600, + "bw_max" : 2670592, + "bw_agg" : 25.028358, + "bw_mean" : 2606494.627119, + "bw_dev" : 37954.776004, + "bw_samples" : 59, + "iops_min" : 600, + "iops_max" : 652, + "iops_mean" : 636.338983, + "iops_stddev" : 9.263592, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4766, + "lat_ns" : { + "min" : 3339454, + "max" : 13463149702145, + "mean" : 2849483971.504616, + "stddev" : 195015378624.850250, + "N" : 4766, + "percentile" : { + "1.000000" : 22151168, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30801920, + "99.500000" : 34340864, + "99.900000" : 42729472, + "99.950000" : 47972352, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.513658, + "sys_cpu" : 32.265157, + "ctx" : 18968, + "majf" : 0, + "minf" : 15, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.903009, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994753, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.052427, + "10" : 0.173010, + "20" : 0.214952, + "50" : 99.554367, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793783915261, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80077651968, + "io_kbytes" : 78200832, + "bw_bytes" : 2667476747, + "bw" : 2604957, + "iops" : 635.976016, + "runtime" : 30020, + "total_ios" : 19092, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 184990, + "max" : 1651667, + "mean" : 565565.154829, + "stddev" : 127295.732481, + "N" : 19092 + }, + "clat_ns" : { + "min" : 2622066, + "max" : 50587052, + "mean" : 24587013.677718, + "stddev" : 1714802.126972, + "N" : 19092, + "percentile" : { + "1.000000" : 21889024, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 28442624, + "99.500000" : 33816576, + "99.900000" : 39059456, + "99.950000" : 39583744, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 3171615, + "max" : 51131851, + "mean" : 25152578.832548, + "stddev" : 1711936.657592, + "N" : 19092 + }, + "bw_min" : 2326528, + "bw_max" : 2703360, + "bw_agg" : 25.039046, + "bw_mean" : 2607607.627119, + "bw_dev" : 52400.736488, + "bw_samples" : 59, + "iops_min" : 568, + "iops_max" : 660, + "iops_mean" : 636.610169, + "iops_stddev" : 12.807618, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4770, + "lat_ns" : { + "min" : 2786336, + "max" : 13463149590165, + "mean" : 2847082786.110080, + "stddev" : 194933592868.316833, + "N" : 4770, + "percentile" : { + "1.000000" : 22151168, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30015488, + "99.500000" : 34340864, + "99.900000" : 40632320, + "99.950000" : 46923776, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.713848, + "sys_cpu" : 32.019721, + "ctx" : 18982, + "majf" : 0, + "minf" : 16, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.900482, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994758, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.062854, + "10" : 0.193798, + "20" : 0.288079, + "50" : 99.450031, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 613758, + "write_ios" : 611972, + "read_sectors" : 156054784, + "write_sectors" : 155753216, + "read_merges" : 2389, + "write_merges" : 4754, + "read_ticks" : 29713374, + "write_ticks" : 14577139, + "in_queue" : 44290513, + "util" : 99.742939 + }, + { + "name" : "nvme2n1", + "read_ios" : 613470, + "write_ios" : 612710, + "read_sectors" : 156132864, + "write_sectors" : 155037680, + "read_merges" : 2985, + "write_merges" : 4732, + "read_ticks" : 29675364, + "write_ticks" : 14653595, + "in_queue" : 44328960, + "util" : 99.779574 + }, + { + "name" : "nvme3n1", + "read_ios" : 614745, + "write_ios" : 611677, + "read_sectors" : 156608256, + "write_sectors" : 155376384, + "read_merges" : 4790, + "write_merges" : 5939, + "read_ticks" : 29673439, + "write_ticks" : 14597282, + "in_queue" : 44270722, + "util" : 99.779559 + }, + { + "name" : "nvme4n1", + "read_ios" : 614921, + "write_ios" : 613279, + "read_sectors" : 156349200, + "write_sectors" : 155482104, + "read_merges" : 4783, + "write_merges" : 2378, + "read_ticks" : 29731026, + "write_ticks" : 14635918, + "in_queue" : 44366945, + "util" : 99.856279 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_2.json new file mode 100644 index 0000000..ed0fb8f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_2.json @@ -0,0 +1,2165 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784067, + "timestamp_ms" : 1793784067327, + "time" : "Wed Nov 4 09:21:07 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784037191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80471916544, + "io_kbytes" : 78585856, + "bw_bytes" : 2677221257, + "bw" : 2614473, + "iops" : 638.299288, + "runtime" : 30058, + "total_ios" : 19186, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 170420, + "max" : 2111037, + "mean" : 576862.343792, + "stddev" : 146029.655605, + "N" : 19186 + }, + "clat_ns" : { + "min" : 12048940, + "max" : 104315641, + "mean" : 49509566.140780, + "stddev" : 4063379.985474, + "N" : 19186, + "percentile" : { + "1.000000" : 38010880, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 47972352, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 49545216, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 64225280, + "99.500000" : 65798144, + "99.900000" : 77070336, + "99.950000" : 92798976, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 13448318, + "max" : 104948040, + "mean" : 50086428.484572, + "stddev" : 4060224.414334, + "N" : 19186 + }, + "bw_min" : 2400256, + "bw_max" : 2779720, + "bw_agg" : 25.013556, + "bw_mean" : 2613548.416667, + "bw_dev" : 59787.472791, + "bw_samples" : 60, + "iops_min" : 586, + "iops_max" : 678, + "iops_mean" : 637.833333, + "iops_stddev" : 14.577864, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.392587, + "sys_cpu" : 42.136607, + "ctx" : 17199, + "majf" : 0, + "minf" : 32783, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838424, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994780, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.333577, + "50" : 65.558220, + "100" : 34.087355, + "250" : 0.020849, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784037191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80249618432, + "io_kbytes" : 78368768, + "bw_bytes" : 2669825618, + "bw" : 2607251, + "iops" : 636.536030, + "runtime" : 30058, + "total_ios" : 19133, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 166560, + "max" : 2065947, + "mean" : 590407.467465, + "stddev" : 157153.769619, + "N" : 19133 + }, + "clat_ns" : { + "min" : 12852049, + "max" : 106641207, + "mean" : 49633487.346835, + "stddev" : 3825638.600200, + "N" : 19133, + "percentile" : { + "1.000000" : 35389440, + "5.000000" : 46923776, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 61603840, + "99.500000" : 65798144, + "99.900000" : 82313216, + "99.950000" : 90701824, + "99.990000" : 104333312 + } + }, + "lat_ns" : { + "min" : 14327757, + "max" : 107270756, + "mean" : 50223894.814300, + "stddev" : 3828937.574332, + "N" : 19133 + }, + "bw_min" : 2334720, + "bw_max" : 2719744, + "bw_agg" : 24.944341, + "bw_mean" : 2606316.766667, + "bw_dev" : 63561.498120, + "bw_samples" : 60, + "iops_min" : 570, + "iops_max" : 664, + "iops_mean" : 636.066667, + "iops_stddev" : 15.496163, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.365971, + "sys_cpu" : 42.615697, + "ctx" : 17464, + "majf" : 0, + "minf" : 32780, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.837976, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994765, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.277008, + "50" : 58.940051, + "100" : 40.762034, + "250" : 0.020906, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784037191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80425779200, + "io_kbytes" : 78540800, + "bw_bytes" : 2675775333, + "bw" : 2613061, + "iops" : 637.954553, + "runtime" : 30057, + "total_ios" : 19175, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 156160, + "max" : 2117917, + "mean" : 569702.708162, + "stddev" : 164825.819598, + "N" : 19175 + }, + "clat_ns" : { + "min" : 12759440, + "max" : 105503869, + "mean" : 49543223.960939, + "stddev" : 3726471.527744, + "N" : 19175, + "percentile" : { + "1.000000" : 36438016, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 62128128, + "99.500000" : 66846720, + "99.900000" : 80216064, + "99.950000" : 90701824, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 14054028, + "max" : 106118508, + "mean" : 50112926.669100, + "stddev" : 3723065.735475, + "N" : 19175 + }, + "bw_min" : 2375680, + "bw_max" : 2752512, + "bw_agg" : 24.999334, + "bw_mean" : 2612062.900000, + "bw_dev" : 65249.258119, + "bw_samples" : 60, + "iops_min" : 580, + "iops_max" : 672, + "iops_mean" : 637.466667, + "iops_stddev" : 15.999435, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30056, + "usr_cpu" : 0.429199, + "sys_cpu" : 40.953553, + "ctx" : 17852, + "majf" : 0, + "minf" : 32782, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838331, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994777, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.229465, + "50" : 61.439374, + "100" : 38.315515, + "250" : 0.015645, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784037191, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80505470976, + "io_kbytes" : 78618624, + "bw_bytes" : 2677892125, + "bw" : 2615129, + "iops" : 638.459236, + "runtime" : 30063, + "total_ios" : 19194, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 163350, + "max" : 1941477, + "mean" : 565343.976764, + "stddev" : 155069.856302, + "N" : 19194 + }, + "clat_ns" : { + "min" : 7849378, + "max" : 108110894, + "mean" : 49507918.736063, + "stddev" : 3642681.344307, + "N" : 19194, + "percentile" : { + "1.000000" : 40632320, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 61603840, + "99.500000" : 64225280, + "99.900000" : 78118912, + "99.950000" : 93847552, + "99.990000" : 106430464 + } + }, + "lat_ns" : { + "min" : 8134807, + "max" : 108560404, + "mean" : 50073262.712827, + "stddev" : 3645086.615907, + "N" : 19194 + }, + "bw_min" : 2375680, + "bw_max" : 2736128, + "bw_agg" : 25.024036, + "bw_mean" : 2614643.666667, + "bw_dev" : 54413.768297, + "bw_samples" : 60, + "iops_min" : 580, + "iops_max" : 668, + "iops_mean" : 638.100000, + "iops_stddev" : 13.283991, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30062, + "usr_cpu" : 0.475684, + "sys_cpu" : 41.168252, + "ctx" : 18013, + "majf" : 0, + "minf" : 32781, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838491, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994782, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.057310, + "20" : 0.192769, + "50" : 62.873815, + "100" : 36.844847, + "250" : 0.031260, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784037226, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80400613376, + "io_kbytes" : 78516224, + "bw_bytes" : 2678234955, + "bw" : 2615463, + "iops" : 638.540973, + "runtime" : 30020, + "total_ios" : 19169, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 187680, + "max" : 1060578, + "mean" : 555112.966613, + "stddev" : 132573.000591, + "N" : 19169 + }, + "clat_ns" : { + "min" : 1939927, + "max" : 47961633, + "mean" : 24496552.695446, + "stddev" : 2331090.650125, + "N" : 19169, + "percentile" : { + "1.000000" : 16711680, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 32636928, + "99.500000" : 35389440, + "99.900000" : 43778048, + "99.950000" : 46399488, + "99.990000" : 47448064 + } + }, + "lat_ns" : { + "min" : 2600136, + "max" : 48426562, + "mean" : 25051665.662059, + "stddev" : 2330372.942253, + "N" : 19169 + }, + "bw_min" : 2534451, + "bw_max" : 2711552, + "bw_agg" : 25.095319, + "bw_mean" : 2617268.830508, + "bw_dev" : 37223.167181, + "bw_samples" : 59, + "iops_min" : 618, + "iops_max" : 662, + "iops_mean" : 638.711864, + "iops_stddev" : 9.125657, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4790, + "lat_ns" : { + "min" : 2663706, + "max" : 13585114856373, + "mean" : 2860720452.422752, + "stddev" : 196288461897.303741, + "N" : 4790, + "percentile" : { + "1.000000" : 19791872, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 33161216, + "99.500000" : 36438016, + "99.900000" : 43253760, + "99.950000" : 45350912, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.513974, + "sys_cpu" : 31.570006, + "ctx" : 19015, + "majf" : 0, + "minf" : 16, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.904794, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994779, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.010000, + "4" : 0.140852, + "10" : 0.417340, + "20" : 0.897282, + "50" : 98.539308, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784037226, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79863742464, + "io_kbytes" : 77991936, + "bw_bytes" : 2660262565, + "bw" : 2597912, + "iops" : 634.256021, + "runtime" : 30021, + "total_ios" : 19041, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 168850, + "max" : 1055718, + "mean" : 573837.844966, + "stddev" : 88692.926123, + "N" : 19041 + }, + "clat_ns" : { + "min" : 2647686, + "max" : 50634279, + "mean" : 24646849.771231, + "stddev" : 1951202.482778, + "N" : 19041, + "percentile" : { + "1.000000" : 21102592, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 31588352, + "99.500000" : 34340864, + "99.900000" : 40632320, + "99.950000" : 45875200, + "99.990000" : 49545216 + } + }, + "lat_ns" : { + "min" : 3116495, + "max" : 51288548, + "mean" : 25220687.616197, + "stddev" : 1951963.927333, + "N" : 19041 + }, + "bw_min" : 2506752, + "bw_max" : 2689788, + "bw_agg" : 24.929009, + "bw_mean" : 2599923.949153, + "bw_dev" : 37430.473426, + "bw_samples" : 59, + "iops_min" : 612, + "iops_max" : 656, + "iops_mean" : 634.474576, + "iops_stddev" : 9.160176, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4758, + "lat_ns" : { + "min" : 2653116, + "max" : 13585114519063, + "mean" : 2879759764.485906, + "stddev" : 196947421891.109619, + "N" : 4758, + "percentile" : { + "1.000000" : 19791872, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 30015488, + "99.500000" : 33161216, + "99.900000" : 36438016, + "99.950000" : 38535168, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.816789, + "sys_cpu" : 32.658228, + "ctx" : 18884, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.904154, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994744, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.078777, + "10" : 0.241584, + "20" : 0.420146, + "50" : 99.254241, + "100" : 0.010000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784037226, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79956017152, + "io_kbytes" : 78082048, + "bw_bytes" : 2663424955, + "bw" : 2601000, + "iops" : 635.009993, + "runtime" : 30020, + "total_ios" : 19063, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 196900, + "max" : 1034368, + "mean" : 592251.317264, + "stddev" : 100097.848487, + "N" : 19063 + }, + "clat_ns" : { + "min" : 2489406, + "max" : 53845453, + "mean" : 24598374.207365, + "stddev" : 2015936.622657, + "N" : 19063, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 31064064, + "99.500000" : 34340864, + "99.900000" : 43778048, + "99.950000" : 47448064, + "99.990000" : 52690944 + } + }, + "lat_ns" : { + "min" : 2999455, + "max" : 54480592, + "mean" : 25190625.524629, + "stddev" : 2016806.439609, + "N" : 19063 + }, + "bw_min" : 2498560, + "bw_max" : 2678784, + "bw_agg" : 24.956949, + "bw_mean" : 2602837.847458, + "bw_dev" : 38135.223804, + "bw_samples" : 59, + "iops_min" : 610, + "iops_max" : 654, + "iops_mean" : 635.186441, + "iops_stddev" : 9.330104, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4763, + "lat_ns" : { + "min" : 2495096, + "max" : 13585114612573, + "mean" : 2876723620.822588, + "stddev" : 196844023045.707886, + "N" : 4763, + "percentile" : { + "1.000000" : 19529728, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 29229056, + "99.500000" : 32374784, + "99.900000" : 36962304, + "99.950000" : 39059456, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.414038, + "sys_cpu" : 32.982444, + "ctx" : 18871, + "majf" : 0, + "minf" : 15, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.901642, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994750, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.089178, + "10" : 0.257042, + "20" : 0.419661, + "50" : 99.218381, + "100" : 0.015737, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784037244, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80392224768, + "io_kbytes" : 78508032, + "bw_bytes" : 2677955521, + "bw" : 2615190, + "iops" : 638.474350, + "runtime" : 30020, + "total_ios" : 19167, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 177270, + "max" : 1238368, + "mean" : 540042.267334, + "stddev" : 104818.777302, + "N" : 19167 + }, + "clat_ns" : { + "min" : 1975797, + "max" : 45177767, + "mean" : 24513831.059425, + "stddev" : 1951370.662989, + "N" : 19167, + "percentile" : { + "1.000000" : 20840448, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30015488, + "99.500000" : 33816576, + "99.900000" : 39583744, + "99.950000" : 41680896, + "99.990000" : 45350912 + } + }, + "lat_ns" : { + "min" : 2451996, + "max" : 45682686, + "mean" : 25053873.326760, + "stddev" : 1947016.230492, + "N" : 19167 + }, + "bw_min" : 2501748, + "bw_max" : 2703360, + "bw_agg" : 25.092155, + "bw_mean" : 2616938.525424, + "bw_dev" : 37199.425462, + "bw_samples" : 59, + "iops_min" : 610, + "iops_max" : 660, + "iops_mean" : 638.644068, + "iops_stddev" : 9.092935, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4789, + "lat_ns" : { + "min" : 2498056, + "max" : 13585132618834, + "mean" : 2861309622.266655, + "stddev" : 196309211274.129517, + "N" : 4789, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 24248320, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30801920, + "99.500000" : 34340864, + "99.900000" : 40108032, + "99.950000" : 40108032, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.940371, + "sys_cpu" : 30.963723, + "ctx" : 19073, + "majf" : 0, + "minf" : 15, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.902176, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994779, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.010000, + "4" : 0.109563, + "10" : 0.281734, + "20" : 0.500861, + "50" : 99.102624, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 612622, + "write_ios" : 614260, + "read_sectors" : 156221440, + "write_sectors" : 156033024, + "read_merges" : 5374, + "write_merges" : 3573, + "read_ticks" : 29611338, + "write_ticks" : 14589364, + "in_queue" : 44200703, + "util" : 99.636242 + }, + { + "name" : "nvme2n1", + "read_ios" : 611578, + "write_ios" : 608958, + "read_sectors" : 155802880, + "write_sectors" : 154987264, + "read_merges" : 4167, + "write_merges" : 4739, + "read_ticks" : 29637635, + "write_ticks" : 14548512, + "in_queue" : 44186148, + "util" : 99.696160 + }, + { + "name" : "nvme3n1", + "read_ios" : 612921, + "write_ios" : 610875, + "read_sectors" : 156144792, + "write_sectors" : 155172608, + "read_merges" : 4186, + "write_merges" : 7108, + "read_ticks" : 29649577, + "write_ticks" : 14579573, + "in_queue" : 44229149, + "util" : 99.716137 + }, + { + "name" : "nvme4n1", + "read_ios" : 613558, + "write_ios" : 612653, + "read_sectors" : 156306944, + "write_sectors" : 155925504, + "read_merges" : 3584, + "write_merges" : 2379, + "read_ticks" : 29656070, + "write_ticks" : 14558719, + "in_queue" : 44214789, + "util" : 99.789417 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_3.json new file mode 100644 index 0000000..e2923a2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fio_mixed/write_full_fsync_3.json @@ -0,0 +1,2165 @@ +{ + "fio version" : "fio-3.36", + "timestamp" : 1793784189, + "timestamp_ms" : 1793784189319, + "time" : "Wed Nov 4 09:23:09 2026", + "global options" : { + "group_reporting" : "0" + }, + "jobs" : [ + { + "jobname" : "r_nvme1n1", + "groupid" : 0, + "job_start" : 1793784159175, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80643883008, + "io_kbytes" : 78753792, + "bw_bytes" : 2683031673, + "bw" : 2620148, + "iops" : 639.684599, + "runtime" : 30057, + "total_ios" : 19227, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 173589, + "max" : 2036346, + "mean" : 528517.257190, + "stddev" : 186918.217382, + "N" : 19227 + }, + "clat_ns" : { + "min" : 12739349, + "max" : 102242318, + "mean" : 49449938.486503, + "stddev" : 3755613.999915, + "N" : 19227, + "percentile" : { + "1.000000" : 37486592, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 47972352, + "30.000000" : 48496640, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 63176704, + "99.500000" : 66322432, + "99.900000" : 79167488, + "99.950000" : 88604672, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 14118587, + "max" : 102713147, + "mean" : 49978455.743694, + "stddev" : 3756818.932440, + "N" : 19227 + }, + "bw_min" : 2342912, + "bw_max" : 2752512, + "bw_agg" : 25.062583, + "bw_mean" : 2619516.116667, + "bw_dev" : 64735.824938, + "bw_samples" : 60, + "iops_min" : 572, + "iops_max" : 672, + "iops_mean" : 639.333333, + "iops_stddev" : 15.926384, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30056, + "usr_cpu" : 0.372638, + "sys_cpu" : 37.526617, + "ctx" : 18757, + "majf" : 0, + "minf" : 32777, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838768, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994791, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.275654, + "50" : 64.419826, + "100" : 35.294118, + "250" : 0.010402, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme2n1", + "groupid" : 0, + "job_start" : 1793784159176, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80564191232, + "io_kbytes" : 78675968, + "bw_bytes" : 2680291144, + "bw" : 2617471, + "iops" : 639.031206, + "runtime" : 30058, + "total_ios" : 19208, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 162609, + "max" : 1921137, + "mean" : 544923.116566, + "stddev" : 147310.544348, + "N" : 19208 + }, + "clat_ns" : { + "min" : 11849940, + "max" : 106320481, + "mean" : 49484247.442940, + "stddev" : 3653665.349535, + "N" : 19208, + "percentile" : { + "1.000000" : 39059456, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50069504, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 61079552, + "99.500000" : 64749568, + "99.900000" : 78118912, + "99.950000" : 92798976, + "99.990000" : 104333312 + } + }, + "lat_ns" : { + "min" : 13413468, + "max" : 106934670, + "mean" : 50029170.559506, + "stddev" : 3649563.458563, + "N" : 19208 + }, + "bw_min" : 2351104, + "bw_max" : 2719744, + "bw_agg" : 25.038377, + "bw_mean" : 2616986.583333, + "bw_dev" : 53787.974307, + "bw_samples" : 60, + "iops_min" : 574, + "iops_max" : 664, + "iops_mean" : 638.733333, + "iops_stddev" : 13.106948, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.399241, + "sys_cpu" : 40.622817, + "ctx" : 17632, + "majf" : 0, + "minf" : 32777, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838609, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994786, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.270721, + "50" : 62.354227, + "100" : 37.349021, + "250" : 0.026031, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme3n1", + "groupid" : 0, + "job_start" : 1793784159176, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80216064000, + "io_kbytes" : 78336000, + "bw_bytes" : 2668709295, + "bw" : 2606161, + "iops" : 636.269878, + "runtime" : 30058, + "total_ios" : 19125, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 171450, + "max" : 2062836, + "mean" : 506673.002405, + "stddev" : 211345.507324, + "N" : 19125 + }, + "clat_ns" : { + "min" : 12869859, + "max" : 102428957, + "mean" : 49740172.272889, + "stddev" : 3765535.828115, + "N" : 19125, + "percentile" : { + "1.000000" : 34340864, + "5.000000" : 47448064, + "10.000000" : 47972352, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49545216, + "50.000000" : 50069504, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 51118080, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 61079552, + "99.500000" : 66322432, + "99.900000" : 77070336, + "99.950000" : 90701824, + "99.990000" : 101187584 + } + }, + "lat_ns" : { + "min" : 14202116, + "max" : 102608727, + "mean" : 50246845.275294, + "stddev" : 3758930.813375, + "N" : 19125 + }, + "bw_min" : 2416640, + "bw_max" : 2755193, + "bw_agg" : 24.929908, + "bw_mean" : 2605649.416667, + "bw_dev" : 58050.105343, + "bw_samples" : 60, + "iops_min" : 590, + "iops_max" : 672, + "iops_mean" : 635.966667, + "iops_stddev" : 14.086857, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.322720, + "sys_cpu" : 34.544366, + "ctx" : 19345, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.837908, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994763, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.287582, + "50" : 53.819608, + "100" : 45.882353, + "250" : 0.010458, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "r_nvme4n1", + "groupid" : 0, + "job_start" : 1793784159176, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "r_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "randread", + "bs" : "4M", + "iodepth" : "32", + "size" : "60G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30" + }, + "read" : { + "io_bytes" : 80278978560, + "io_kbytes" : 78397440, + "bw_bytes" : 2670802400, + "bw" : 2608205, + "iops" : 636.768913, + "runtime" : 30058, + "total_ios" : 19140, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 181960, + "max" : 2120747, + "mean" : 568623.557785, + "stddev" : 126425.452911, + "N" : 19140 + }, + "clat_ns" : { + "min" : 11359261, + "max" : 105433642, + "mean" : 49637372.606844, + "stddev" : 3546340.757145, + "N" : 19140, + "percentile" : { + "1.000000" : 42729472, + "5.000000" : 46923776, + "10.000000" : 47448064, + "20.000000" : 48496640, + "30.000000" : 49020928, + "40.000000" : 49020928, + "50.000000" : 49545216, + "60.000000" : 50069504, + "70.000000" : 50593792, + "80.000000" : 50593792, + "90.000000" : 51642368, + "95.000000" : 52166656, + "99.000000" : 62652416, + "99.500000" : 65273856, + "99.900000" : 78118912, + "99.950000" : 88604672, + "99.990000" : 103284736 + } + }, + "lat_ns" : { + "min" : 12903239, + "max" : 105940621, + "mean" : 50205996.164629, + "stddev" : 3541555.428813, + "N" : 19140 + }, + "bw_min" : 2326528, + "bw_max" : 2883584, + "bw_agg" : 24.949675, + "bw_mean" : 2607715.116667, + "bw_dev" : 72822.954119, + "bw_samples" : 60, + "iops_min" : 568, + "iops_max" : 704, + "iops_mean" : 636.466667, + "iops_stddev" : 17.806366, + "iops_samples" : 60 + }, + "write" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 0, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + } + }, + "job_runtime" : 30057, + "usr_cpu" : 0.405895, + "sys_cpu" : 42.642313, + "ctx" : 17014, + "majf" : 0, + "minf" : 32779, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 0.100000, + "32" : 99.838036, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994767, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.100000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.229885, + "50" : 60.250784, + "100" : 39.498433, + "250" : 0.020899, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 32, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme1n1", + "groupid" : 0, + "job_start" : 1793784159210, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme1n1", + "filename" : "/dev/nvme1n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80308338688, + "io_kbytes" : 78426112, + "bw_bytes" : 2675161182, + "bw" : 2612462, + "iops" : 637.808128, + "runtime" : 30020, + "total_ios" : 19147, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 194510, + "max" : 1155328, + "mean" : 601143.754061, + "stddev" : 108856.197329, + "N" : 19147 + }, + "clat_ns" : { + "min" : 2119027, + "max" : 52894851, + "mean" : 24478965.395415, + "stddev" : 2193814.664220, + "N" : 19147, + "percentile" : { + "1.000000" : 19791872, + "5.000000" : 22937600, + "10.000000" : 23199744, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 25821184, + "99.000000" : 32112640, + "99.500000" : 34865152, + "99.900000" : 45350912, + "99.950000" : 47972352, + "99.990000" : 51642368 + } + }, + "lat_ns" : { + "min" : 2455326, + "max" : 53165690, + "mean" : 25080109.149475, + "stddev" : 2192212.957200, + "N" : 19147 + }, + "bw_min" : 2514944, + "bw_max" : 2711552, + "bw_agg" : 25.087850, + "bw_mean" : 2615291.220339, + "bw_dev" : 39817.206156, + "bw_samples" : 59, + "iops_min" : 614, + "iops_max" : 662, + "iops_mean" : 638.338983, + "iops_stddev" : 9.749642, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4784, + "lat_ns" : { + "min" : 2807535, + "max" : 13707098536874, + "mean" : 2889718736.066036, + "stddev" : 198175139339.426849, + "N" : 4784, + "percentile" : { + "1.000000" : 20578304, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 32899072, + "99.500000" : 36438016, + "99.900000" : 46923776, + "99.950000" : 49020928, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30019, + "usr_cpu" : 9.787135, + "sys_cpu" : 34.711349, + "ctx" : 18930, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.902073, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994773, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.120123, + "10" : 0.313365, + "20" : 0.652844, + "50" : 98.892777, + "100" : 0.020891, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme2n1", + "groupid" : 0, + "job_start" : 1793784159210, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme2n1", + "filename" : "/dev/nvme2n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79997960192, + "io_kbytes" : 78123008, + "bw_bytes" : 2664733359, + "bw" : 2602278, + "iops" : 635.321941, + "runtime" : 30021, + "total_ios" : 19073, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 193460, + "max" : 1090078, + "mean" : 608909.272427, + "stddev" : 88520.141701, + "N" : 19073 + }, + "clat_ns" : { + "min" : 2443076, + "max" : 49115737, + "mean" : 24569465.708436, + "stddev" : 1942698.838908, + "N" : 19073, + "percentile" : { + "1.000000" : 20840448, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 31064064, + "99.500000" : 34340864, + "99.900000" : 41156608, + "99.950000" : 45350912, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 2951175, + "max" : 49601777, + "mean" : 25178374.980863, + "stddev" : 1942208.388663, + "N" : 19073 + }, + "bw_min" : 2498560, + "bw_max" : 2695168, + "bw_agg" : 24.990675, + "bw_mean" : 2605161.169492, + "bw_dev" : 43396.589759, + "bw_samples" : 59, + "iops_min" : 610, + "iops_max" : 658, + "iops_mean" : 635.864407, + "iops_stddev" : 10.634131, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4766, + "lat_ns" : { + "min" : 2589495, + "max" : 13707098929354, + "mean" : 2900541167.453422, + "stddev" : 198549021503.116486, + "N" : 4766, + "percentile" : { + "1.000000" : 20316160, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30277632, + "99.500000" : 33423360, + "99.900000" : 42729472, + "99.950000" : 46923776, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.337109, + "sys_cpu" : 34.663558, + "ctx" : 18901, + "majf" : 0, + "minf" : 12, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.904315, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994753, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.083888, + "10" : 0.220207, + "20" : 0.519058, + "50" : 99.176847, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme3n1", + "groupid" : 0, + "job_start" : 1793784159211, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme3n1", + "filename" : "/dev/nvme3n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 79863742464, + "io_kbytes" : 77991936, + "bw_bytes" : 2660262565, + "bw" : 2597912, + "iops" : 634.256021, + "runtime" : 30021, + "total_ios" : 19041, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 180630, + "max" : 1008908, + "mean" : 576761.623339, + "stddev" : 89035.788341, + "N" : 19041 + }, + "clat_ns" : { + "min" : 2370226, + "max" : 49665107, + "mean" : 24643332.457539, + "stddev" : 1886583.341505, + "N" : 19041, + "percentile" : { + "1.000000" : 21364736, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 31326208, + "99.500000" : 33816576, + "99.900000" : 40632320, + "99.950000" : 43778048, + "99.990000" : 49020928 + } + }, + "lat_ns" : { + "min" : 2689626, + "max" : 50388526, + "mean" : 25220094.080878, + "stddev" : 1888456.335843, + "N" : 19041 + }, + "bw_min" : 2473984, + "bw_max" : 2654208, + "bw_agg" : 24.963605, + "bw_mean" : 2602339.406780, + "bw_dev" : 37567.575696, + "bw_samples" : 59, + "iops_min" : 604, + "iops_max" : 648, + "iops_mean" : 635.169492, + "iops_stddev" : 9.244108, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4758, + "lat_ns" : { + "min" : 2770536, + "max" : 13707099013794, + "mean" : 2905483027.481931, + "stddev" : 198715869133.607849, + "N" : 4758, + "percentile" : { + "1.000000" : 21626880, + "5.000000" : 23199744, + "10.000000" : 23461888, + "20.000000" : 23986176, + "30.000000" : 24248320, + "40.000000" : 24510464, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25821184, + "95.000000" : 26083328, + "99.000000" : 31326208, + "99.500000" : 33816576, + "99.900000" : 40632320, + "99.950000" : 43778048, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.706862, + "sys_cpu" : 33.377748, + "ctx" : 18897, + "majf" : 0, + "minf" : 14, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.904154, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994744, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.073526, + "10" : 0.220577, + "20" : 0.336117, + "50" : 99.369781, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + }, + { + "jobname" : "w_nvme4n1", + "groupid" : 0, + "job_start" : 1793784159210, + "error" : 0, + "eta" : 0, + "elapsed" : 31, + "job options" : { + "name" : "w_nvme4n1", + "filename" : "/dev/nvme4n1", + "rw" : "write", + "bs" : "4M", + "iodepth" : "16", + "offset" : "100G", + "size" : "1000G", + "ioengine" : "libaio", + "direct" : "1", + "runtime" : "30", + "fsync" : "4" + }, + "read" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "write" : { + "io_bytes" : 80295755776, + "io_kbytes" : 78413824, + "bw_bytes" : 2674652935, + "bw" : 2611965, + "iops" : 637.686952, + "runtime" : 30021, + "total_ios" : 19144, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 190320, + "max" : 1081298, + "mean" : 583704.441548, + "stddev" : 90623.823008, + "N" : 19144 + }, + "clat_ns" : { + "min" : 2171326, + "max" : 47363960, + "mean" : 24500841.604106, + "stddev" : 1984569.221392, + "N" : 19144, + "percentile" : { + "1.000000" : 20316160, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30801920, + "99.500000" : 33816576, + "99.900000" : 39059456, + "99.950000" : 40108032, + "99.990000" : 46923776 + } + }, + "lat_ns" : { + "min" : 2637426, + "max" : 47946709, + "mean" : 25084546.045654, + "stddev" : 1982374.886470, + "N" : 19144 + }, + "bw_min" : 2449408, + "bw_max" : 2686976, + "bw_agg" : 25.085174, + "bw_mean" : 2615012.966102, + "bw_dev" : 43456.446241, + "bw_samples" : 59, + "iops_min" : 598, + "iops_max" : 656, + "iops_mean" : 638.271186, + "iops_stddev" : 10.631493, + "iops_samples" : 59 + }, + "trim" : { + "io_bytes" : 0, + "io_kbytes" : 0, + "bw_bytes" : 0, + "bw" : 0, + "iops" : 0.000000, + "runtime" : 0, + "total_ios" : 0, + "short_ios" : 0, + "drop_ios" : 0, + "slat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "clat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "lat_ns" : { + "min" : 0, + "max" : 0, + "mean" : 0.000000, + "stddev" : 0.000000, + "N" : 0 + }, + "bw_min" : 0, + "bw_max" : 0, + "bw_agg" : 0.000000, + "bw_mean" : 0.000000, + "bw_dev" : 0.000000, + "bw_samples" : 0, + "iops_min" : 0, + "iops_max" : 0, + "iops_mean" : 0.000000, + "iops_stddev" : 0.000000, + "iops_samples" : 0 + }, + "sync" : { + "total_ios" : 4783, + "lat_ns" : { + "min" : 2181446, + "max" : 13707098989134, + "mean" : 2890295296.101821, + "stddev" : 198195861735.246857, + "N" : 4783, + "percentile" : { + "1.000000" : 20054016, + "5.000000" : 22937600, + "10.000000" : 23461888, + "20.000000" : 23724032, + "30.000000" : 23986176, + "40.000000" : 24248320, + "50.000000" : 24510464, + "60.000000" : 24772608, + "70.000000" : 25034752, + "80.000000" : 25296896, + "90.000000" : 25559040, + "95.000000" : 26083328, + "99.000000" : 30539776, + "99.500000" : 33816576, + "99.900000" : 40108032, + "99.950000" : 46399488, + "99.990000" : 17112760320 + } + } + }, + "job_runtime" : 30020, + "usr_cpu" : 9.690207, + "sys_cpu" : 32.611592, + "ctx" : 18980, + "majf" : 0, + "minf" : 15, + "iodepth_level" : { + "1" : 0.100000, + "2" : 0.100000, + "4" : 0.100000, + "8" : 0.100000, + "16" : 124.900752, + "32" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_submit" : { + "0" : 0.000000, + "4" : 100.000000, + "8" : 0.000000, + "16" : 0.000000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "iodepth_complete" : { + "0" : 0.000000, + "4" : 99.994773, + "8" : 0.000000, + "16" : 0.100000, + "32" : 0.000000, + "64" : 0.000000, + ">=64" : 0.000000 + }, + "latency_ns" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_us" : { + "2" : 0.000000, + "4" : 0.000000, + "10" : 0.000000, + "20" : 0.000000, + "50" : 0.000000, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000 + }, + "latency_ms" : { + "2" : 0.000000, + "4" : 0.114919, + "10" : 0.308191, + "20" : 0.496239, + "50" : 99.080652, + "100" : 0.000000, + "250" : 0.000000, + "500" : 0.000000, + "750" : 0.000000, + "1000" : 0.000000, + "2000" : 0.000000, + ">=2000" : 0.000000 + }, + "latency_depth" : 16, + "latency_target" : 0, + "latency_percentile" : 100.000000, + "latency_window" : 0 + } + ], + "disk_util" : [ + { + "name" : "nvme1n1", + "read_ios" : 614308, + "write_ios" : 613282, + "read_sectors" : 156498688, + "write_sectors" : 155784960, + "read_merges" : 4184, + "write_merges" : 3561, + "read_ticks" : 29668957, + "write_ticks" : 14564222, + "in_queue" : 44233178, + "util" : 99.662783 + }, + { + "name" : "nvme2n1", + "read_ios" : 613204, + "write_ios" : 610982, + "read_sectors" : 156369152, + "write_sectors" : 155201280, + "read_merges" : 2987, + "write_merges" : 7115, + "read_ticks" : 29618404, + "write_ticks" : 14566345, + "in_queue" : 44184750, + "util" : 99.702719 + }, + { + "name" : "nvme3n1", + "read_ios" : 610744, + "write_ios" : 607890, + "read_sectors" : 155590656, + "write_sectors" : 155014144, + "read_merges" : 2982, + "write_merges" : 4729, + "read_ticks" : 29695043, + "write_ticks" : 14511344, + "in_queue" : 44206388, + "util" : 99.726055 + }, + { + "name" : "nvme4n1", + "read_ios" : 610495, + "write_ios" : 610967, + "read_sectors" : 155829760, + "write_sectors" : 155799296, + "read_merges" : 4171, + "write_merges" : 8332, + "read_ticks" : 29581771, + "write_ticks" : 14506321, + "in_queue" : 44088092, + "util" : 99.809396 + } + ] +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.cpu new file mode 100644 index 0000000..f091492 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.498207807540894, "user_s": 158.818691, "sys_s": 63.342016, "max_rss_kb": 15054640} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.json new file mode 100644 index 0000000..2e20dfa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 819.11, + "duration_min_ms": 772.21, + "duration_max_ms": 855.09, + "duration_p50_ms": 796.23, + "duration_p99_ms": 855.09, + "duration_std_ms": 32.71, + "throughput_avg_mbps": 8764.44, + "throughput_min_mbps": 8382.72, + "throughput_max_mbps": 9282.46, + "ops_per_sec_avg": 626.03, + "latency_per_key_ms": 1.6 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 11.5, + "duration_min_ms": 10.1, + "duration_max_ms": 12.98, + "duration_p50_ms": 11.43, + "duration_p99_ms": 12.98, + "duration_std_ms": 0.84, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 44764.16, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 681.27, + "duration_min_ms": 661.76, + "duration_max_ms": 716.23, + "duration_p50_ms": 676.33, + "duration_p99_ms": 716.23, + "duration_std_ms": 13.87, + "throughput_avg_mbps": 10525.67, + "throughput_min_mbps": 10008.01, + "throughput_max_mbps": 10831.68, + "ops_per_sec_avg": 751.83, + "latency_per_key_ms": 1.331 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.cpu new file mode 100644 index 0000000..c273856 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.64422583580017, "user_s": 156.507062, "sys_s": 63.26027, "max_rss_kb": 15058276} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.json new file mode 100644 index 0000000..fcc3f42 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 825.34, + "duration_min_ms": 806.32, + "duration_max_ms": 843.76, + "duration_p50_ms": 817.61, + "duration_p99_ms": 843.76, + "duration_std_ms": 14.11, + "throughput_avg_mbps": 8687.38, + "throughput_min_mbps": 8495.32, + "throughput_max_mbps": 8889.8, + "ops_per_sec_avg": 620.53, + "latency_per_key_ms": 1.612 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 11.34, + "duration_min_ms": 10.02, + "duration_max_ms": 12.86, + "duration_p50_ms": 10.98, + "duration_p99_ms": 12.86, + "duration_std_ms": 0.97, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 45465.37, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 680.19, + "duration_min_ms": 666.35, + "duration_max_ms": 731.55, + "duration_p50_ms": 678.93, + "duration_p99_ms": 731.55, + "duration_std_ms": 12.43, + "throughput_avg_mbps": 10541.41, + "throughput_min_mbps": 9798.34, + "throughput_max_mbps": 10757.15, + "ops_per_sec_avg": 752.96, + "latency_per_key_ms": 1.329 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.cpu new file mode 100644 index 0000000..00ec062 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.79967379570007, "user_s": 157.749261, "sys_s": 64.895774, "max_rss_kb": 15056220} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.json new file mode 100644 index 0000000..d52dd31 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d2_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 820.57, + "duration_min_ms": 780.62, + "duration_max_ms": 863.55, + "duration_p50_ms": 807.57, + "duration_p99_ms": 863.55, + "duration_std_ms": 27.87, + "throughput_avg_mbps": 8745.1, + "throughput_min_mbps": 8300.58, + "throughput_max_mbps": 9182.4, + "ops_per_sec_avg": 624.65, + "latency_per_key_ms": 1.603 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.95, + "duration_min_ms": 9.86, + "duration_max_ms": 11.64, + "duration_p50_ms": 11.01, + "duration_p99_ms": 11.64, + "duration_std_ms": 0.52, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46842.29, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 690.28, + "duration_min_ms": 671.86, + "duration_max_ms": 744.03, + "duration_p50_ms": 686.93, + "duration_p99_ms": 744.03, + "duration_std_ms": 16.89, + "throughput_avg_mbps": 10389.94, + "throughput_min_mbps": 9633.97, + "throughput_max_mbps": 10668.95, + "ops_per_sec_avg": 742.14, + "latency_per_key_ms": 1.348 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.cpu new file mode 100644 index 0000000..e5deb15 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 61.15494155883789, "user_s": 294.563487, "sys_s": 105.861634, "max_rss_kb": 15063908} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.json new file mode 100644 index 0000000..6d4caea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 480.9, + "duration_min_ms": 434.43, + "duration_max_ms": 559.74, + "duration_p50_ms": 471.75, + "duration_p99_ms": 559.74, + "duration_std_ms": 30.5, + "throughput_avg_mbps": 14962.47, + "throughput_min_mbps": 12805.84, + "throughput_max_mbps": 16499.75, + "ops_per_sec_avg": 1068.75, + "latency_per_key_ms": 0.939 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.36, + "duration_min_ms": 9.92, + "duration_max_ms": 11.02, + "duration_p50_ms": 10.3, + "duration_p99_ms": 11.02, + "duration_std_ms": 0.23, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49460.26, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 383.31, + "duration_min_ms": 363.54, + "duration_max_ms": 408.48, + "duration_p50_ms": 383.89, + "duration_p99_ms": 408.48, + "duration_std_ms": 10.26, + "throughput_avg_mbps": 18713.45, + "throughput_min_mbps": 17548.07, + "throughput_max_mbps": 19717.46, + "ops_per_sec_avg": 1336.68, + "latency_per_key_ms": 0.749 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.cpu new file mode 100644 index 0000000..354c81d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 61.969332695007324, "user_s": 295.211475, "sys_s": 106.31514, "max_rss_kb": 15063512} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.json new file mode 100644 index 0000000..34a35a0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 496.31, + "duration_min_ms": 454.47, + "duration_max_ms": 627.15, + "duration_p50_ms": 485.26, + "duration_p99_ms": 627.15, + "duration_std_ms": 38.61, + "throughput_avg_mbps": 14518.84, + "throughput_min_mbps": 11429.41, + "throughput_max_mbps": 15772.35, + "ops_per_sec_avg": 1037.06, + "latency_per_key_ms": 0.969 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.49, + "duration_min_ms": 9.85, + "duration_max_ms": 11.74, + "duration_p50_ms": 10.44, + "duration_p99_ms": 11.74, + "duration_std_ms": 0.41, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48861.33, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 381.97, + "duration_min_ms": 356.86, + "duration_max_ms": 403.61, + "duration_p50_ms": 382.19, + "duration_p99_ms": 403.61, + "duration_std_ms": 10.79, + "throughput_avg_mbps": 18780.74, + "throughput_min_mbps": 17759.91, + "throughput_max_mbps": 20086.43, + "ops_per_sec_avg": 1341.48, + "latency_per_key_ms": 0.746 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.cpu new file mode 100644 index 0000000..9e64ceb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 61.23014950752258, "user_s": 295.555588, "sys_s": 106.519234, "max_rss_kb": 15066108} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.json new file mode 100644 index 0000000..2122898 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w128-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 479.19, + "duration_min_ms": 447.11, + "duration_max_ms": 556.28, + "duration_p50_ms": 472.43, + "duration_p99_ms": 556.28, + "duration_std_ms": 20.05, + "throughput_avg_mbps": 14982.79, + "throughput_min_mbps": 12885.55, + "throughput_max_mbps": 16031.83, + "ops_per_sec_avg": 1070.2, + "latency_per_key_ms": 0.936 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.67, + "duration_min_ms": 10.12, + "duration_max_ms": 11.44, + "duration_p50_ms": 10.65, + "duration_p99_ms": 11.44, + "duration_std_ms": 0.29, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48033.56, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 385.11, + "duration_min_ms": 367.88, + "duration_max_ms": 403.39, + "duration_p50_ms": 384.19, + "duration_p99_ms": 403.39, + "duration_std_ms": 8.49, + "throughput_avg_mbps": 18621.79, + "throughput_min_mbps": 17769.53, + "throughput_max_mbps": 19484.56, + "ops_per_sec_avg": 1330.13, + "latency_per_key_ms": 0.752 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.cpu new file mode 100644 index 0000000..2951277 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 57.27785515785217, "user_s": 296.54649, "sys_s": 105.633182, "max_rss_kb": 15062168} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.json new file mode 100644 index 0000000..175d0af --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 451.01, + "duration_min_ms": 407.73, + "duration_max_ms": 577.69, + "duration_p50_ms": 443.07, + "duration_p99_ms": 577.69, + "duration_std_ms": 34.63, + "throughput_avg_mbps": 15977.09, + "throughput_min_mbps": 12408.09, + "throughput_max_mbps": 17580.23, + "ops_per_sec_avg": 1141.22, + "latency_per_key_ms": 0.881 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.08, + "duration_min_ms": 10.28, + "duration_max_ms": 12.5, + "duration_p50_ms": 11.05, + "duration_p99_ms": 12.5, + "duration_std_ms": 0.61, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46336.67, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 345.68, + "duration_min_ms": 336.58, + "duration_max_ms": 358.83, + "duration_p50_ms": 345.19, + "duration_p99_ms": 358.83, + "duration_std_ms": 5.12, + "throughput_avg_mbps": 20740.33, + "throughput_min_mbps": 19976.09, + "throughput_max_mbps": 21296.47, + "ops_per_sec_avg": 1481.45, + "latency_per_key_ms": 0.675 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.cpu new file mode 100644 index 0000000..3bc41d2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.891106605529785, "user_s": 297.630028, "sys_s": 106.588935, "max_rss_kb": 15063132} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.json new file mode 100644 index 0000000..e95a450 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 445.17, + "duration_min_ms": 420.58, + "duration_max_ms": 543.05, + "duration_p50_ms": 440.62, + "duration_p99_ms": 543.05, + "duration_std_ms": 19.33, + "throughput_avg_mbps": 16128.53, + "throughput_min_mbps": 13199.57, + "throughput_max_mbps": 17043.25, + "ops_per_sec_avg": 1152.04, + "latency_per_key_ms": 0.869 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 9.91, + "duration_min_ms": 8.69, + "duration_max_ms": 10.96, + "duration_p50_ms": 10.01, + "duration_p99_ms": 10.96, + "duration_std_ms": 0.51, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 51832.23, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 346.28, + "duration_min_ms": 334.81, + "duration_max_ms": 368.51, + "duration_p50_ms": 346.46, + "duration_p99_ms": 368.51, + "duration_std_ms": 6.66, + "throughput_avg_mbps": 20707.2, + "throughput_min_mbps": 19451.12, + "throughput_max_mbps": 21409.26, + "ops_per_sec_avg": 1479.09, + "latency_per_key_ms": 0.676 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.cpu new file mode 100644 index 0000000..5d40087 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.52006697654724, "user_s": 296.715933, "sys_s": 106.191509, "max_rss_kb": 15060776} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.json new file mode 100644 index 0000000..762b264 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_14mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 441.15, + "duration_min_ms": 422.8, + "duration_max_ms": 490.61, + "duration_p50_ms": 437.93, + "duration_p99_ms": 490.61, + "duration_std_ms": 12.72, + "throughput_avg_mbps": 16260.97, + "throughput_min_mbps": 14610.52, + "throughput_max_mbps": 16953.71, + "ops_per_sec_avg": 1161.5, + "latency_per_key_ms": 0.862 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.42, + "duration_min_ms": 9.98, + "duration_max_ms": 11.88, + "duration_p50_ms": 10.24, + "duration_p99_ms": 11.88, + "duration_std_ms": 0.42, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49198.26, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 343.26, + "duration_min_ms": 331.73, + "duration_max_ms": 353.87, + "duration_p50_ms": 343.21, + "duration_p99_ms": 353.87, + "duration_std_ms": 4.91, + "throughput_avg_mbps": 20886.52, + "throughput_min_mbps": 20256.05, + "throughput_max_mbps": 21607.92, + "ops_per_sec_avg": 1491.89, + "latency_per_key_ms": 0.67 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.cpu new file mode 100644 index 0000000..07e6d7b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 57.875545501708984, "user_s": 333.685836, "sys_s": 117.805464, "max_rss_kb": 17149236} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.json new file mode 100644 index 0000000..e269d0d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 447.33, + "duration_min_ms": 416.56, + "duration_max_ms": 516.27, + "duration_p50_ms": 445.69, + "duration_p99_ms": 516.27, + "duration_std_ms": 20.33, + "throughput_avg_mbps": 18349.19, + "throughput_min_mbps": 15867.74, + "throughput_max_mbps": 19665.88, + "ops_per_sec_avg": 1146.82, + "latency_per_key_ms": 0.874 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.6, + "duration_min_ms": 9.99, + "duration_max_ms": 11.06, + "duration_p50_ms": 10.55, + "duration_p99_ms": 11.06, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48328.37, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 347.41, + "duration_min_ms": 331.61, + "duration_max_ms": 360.92, + "duration_p50_ms": 346.76, + "duration_p99_ms": 360.92, + "duration_std_ms": 5.97, + "throughput_avg_mbps": 23587.11, + "throughput_min_mbps": 22697.29, + "throughput_max_mbps": 24703.38, + "ops_per_sec_avg": 1474.19, + "latency_per_key_ms": 0.679 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.cpu new file mode 100644 index 0000000..fa40e3d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 58.05755662918091, "user_s": 337.051563, "sys_s": 123.964591, "max_rss_kb": 17149264} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.json new file mode 100644 index 0000000..658d373 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 452.59, + "duration_min_ms": 433.85, + "duration_max_ms": 527.39, + "duration_p50_ms": 446.91, + "duration_p99_ms": 527.39, + "duration_std_ms": 15.13, + "throughput_avg_mbps": 18118.63, + "throughput_min_mbps": 15532.99, + "throughput_max_mbps": 18882.29, + "ops_per_sec_avg": 1132.41, + "latency_per_key_ms": 0.884 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.87, + "duration_min_ms": 10.12, + "duration_max_ms": 12.3, + "duration_p50_ms": 10.82, + "duration_p99_ms": 12.3, + "duration_std_ms": 0.42, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47186.01, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 344.48, + "duration_min_ms": 331.0, + "duration_max_ms": 362.94, + "duration_p50_ms": 344.21, + "duration_p99_ms": 362.94, + "duration_std_ms": 7.09, + "throughput_avg_mbps": 23790.35, + "throughput_min_mbps": 22571.45, + "throughput_max_mbps": 24749.26, + "ops_per_sec_avg": 1486.9, + "latency_per_key_ms": 0.673 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.cpu new file mode 100644 index 0000000..6e23717 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 58.27586078643799, "user_s": 335.637706, "sys_s": 120.599499, "max_rss_kb": 17151328} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.json new file mode 100644 index 0000000..13a1506 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_16mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 452.3, + "duration_min_ms": 420.68, + "duration_max_ms": 519.81, + "duration_p50_ms": 450.3, + "duration_p99_ms": 519.81, + "duration_std_ms": 19.6, + "throughput_avg_mbps": 18143.52, + "throughput_min_mbps": 15759.46, + "throughput_max_mbps": 19473.3, + "ops_per_sec_avg": 1133.97, + "latency_per_key_ms": 0.883 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.69, + "duration_min_ms": 10.03, + "duration_max_ms": 13.0, + "duration_p50_ms": 10.48, + "duration_p99_ms": 13.0, + "duration_std_ms": 0.7, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48092.38, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 348.17, + "duration_min_ms": 335.89, + "duration_max_ms": 368.79, + "duration_p50_ms": 348.36, + "duration_p99_ms": 368.79, + "duration_std_ms": 6.44, + "throughput_avg_mbps": 23536.25, + "throughput_min_mbps": 22213.17, + "throughput_max_mbps": 24389.16, + "ops_per_sec_avg": 1471.02, + "latency_per_key_ms": 0.68 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.cpu new file mode 100644 index 0000000..5b85f17 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.209932565689087, "user_s": 117.006358, "sys_s": 29.848617, "max_rss_kb": 2472536} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.json new file mode 100644 index 0000000..7868587 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 207.54, + "duration_min_ms": 187.34, + "duration_max_ms": 304.87, + "duration_p50_ms": 208.66, + "duration_p99_ms": 304.87, + "duration_std_ms": 17.0, + "throughput_avg_mbps": 4961.73, + "throughput_min_mbps": 3358.82, + "throughput_max_mbps": 5465.91, + "ops_per_sec_avg": 2480.87, + "latency_per_key_ms": 0.405 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 10.48, + "duration_min_ms": 10.05, + "duration_max_ms": 11.28, + "duration_p50_ms": 10.42, + "duration_p99_ms": 11.28, + "duration_std_ms": 0.25, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48881.59, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 161.26, + "duration_min_ms": 159.65, + "duration_max_ms": 162.69, + "duration_p50_ms": 161.39, + "duration_p99_ms": 162.69, + "duration_std_ms": 0.82, + "throughput_avg_mbps": 6350.35, + "throughput_min_mbps": 6294.26, + "throughput_max_mbps": 6413.89, + "ops_per_sec_avg": 3175.17, + "latency_per_key_ms": 0.315 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.cpu new file mode 100644 index 0000000..12606e8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.5111141204834, "user_s": 113.93285, "sys_s": 29.458233, "max_rss_kb": 2470572} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.json new file mode 100644 index 0000000..722ab51 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 209.24, + "duration_min_ms": 185.7, + "duration_max_ms": 297.58, + "duration_p50_ms": 207.55, + "duration_p99_ms": 297.58, + "duration_std_ms": 16.58, + "throughput_avg_mbps": 4920.18, + "throughput_min_mbps": 3441.06, + "throughput_max_mbps": 5514.39, + "ops_per_sec_avg": 2460.09, + "latency_per_key_ms": 0.409 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 11.03, + "duration_min_ms": 10.12, + "duration_max_ms": 12.04, + "duration_p50_ms": 11.08, + "duration_p99_ms": 12.04, + "duration_std_ms": 0.47, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46485.44, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 164.34, + "duration_min_ms": 162.57, + "duration_max_ms": 166.99, + "duration_p50_ms": 164.29, + "duration_p99_ms": 166.99, + "duration_std_ms": 0.95, + "throughput_avg_mbps": 6231.37, + "throughput_min_mbps": 6132.24, + "throughput_max_mbps": 6298.65, + "ops_per_sec_avg": 3115.68, + "latency_per_key_ms": 0.321 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.cpu new file mode 100644 index 0000000..ebd88d7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 31.1767840385437, "user_s": 115.731627, "sys_s": 29.940158, "max_rss_kb": 2471504} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.json new file mode 100644 index 0000000..378d7bc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/base_2mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 206.29, + "duration_min_ms": 184.97, + "duration_max_ms": 304.65, + "duration_p50_ms": 207.24, + "duration_p99_ms": 304.65, + "duration_std_ms": 16.17, + "throughput_avg_mbps": 4988.85, + "throughput_min_mbps": 3361.25, + "throughput_max_mbps": 5536.02, + "ops_per_sec_avg": 2494.42, + "latency_per_key_ms": 0.403 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 10.85, + "duration_min_ms": 10.02, + "duration_max_ms": 11.75, + "duration_p50_ms": 10.64, + "duration_p99_ms": 11.75, + "duration_std_ms": 0.51, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47280.04, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 162.0, + "duration_min_ms": 160.22, + "duration_max_ms": 164.11, + "duration_p50_ms": 162.07, + "duration_p99_ms": 164.11, + "duration_std_ms": 1.0, + "throughput_avg_mbps": 6321.21, + "throughput_min_mbps": 6239.79, + "throughput_max_mbps": 6391.31, + "ops_per_sec_avg": 3160.61, + "latency_per_key_ms": 0.316 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.cpu new file mode 100644 index 0000000..1aa2df0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.087183237075806, "user_s": 158.781879, "sys_s": 66.863853, "max_rss_kb": 15055232} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.json new file mode 100644 index 0000000..1b153a9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 756.77, + "duration_min_ms": 704.76, + "duration_max_ms": 830.6, + "duration_p50_ms": 745.13, + "duration_p99_ms": 830.6, + "duration_std_ms": 40.23, + "throughput_avg_mbps": 9497.31, + "throughput_min_mbps": 8629.92, + "throughput_max_mbps": 10170.78, + "ops_per_sec_avg": 678.38, + "latency_per_key_ms": 1.478 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.61, + "duration_min_ms": 10.03, + "duration_max_ms": 11.69, + "duration_p50_ms": 10.31, + "duration_p99_ms": 11.69, + "duration_std_ms": 0.51, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48350.96, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 596.73, + "duration_min_ms": 581.54, + "duration_max_ms": 613.74, + "duration_p50_ms": 596.29, + "duration_p99_ms": 613.74, + "duration_std_ms": 6.61, + "throughput_avg_mbps": 12013.64, + "throughput_min_mbps": 11679.25, + "throughput_max_mbps": 12325.83, + "ops_per_sec_avg": 858.12, + "latency_per_key_ms": 1.165 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.cpu new file mode 100644 index 0000000..32ec6c7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.51193380355835, "user_s": 159.844557, "sys_s": 67.240875, "max_rss_kb": 15054820} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.json new file mode 100644 index 0000000..beb4405 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 746.13, + "duration_min_ms": 737.64, + "duration_max_ms": 765.51, + "duration_p50_ms": 745.53, + "duration_p99_ms": 765.51, + "duration_std_ms": 6.95, + "throughput_avg_mbps": 9607.69, + "throughput_min_mbps": 9363.66, + "throughput_max_mbps": 9717.51, + "ops_per_sec_avg": 686.26, + "latency_per_key_ms": 1.457 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.83, + "duration_min_ms": 10.05, + "duration_max_ms": 12.05, + "duration_p50_ms": 10.56, + "duration_p99_ms": 12.05, + "duration_std_ms": 0.57, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47408.2, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 586.81, + "duration_min_ms": 575.48, + "duration_max_ms": 607.34, + "duration_p50_ms": 584.72, + "duration_p99_ms": 607.34, + "duration_std_ms": 6.83, + "throughput_avg_mbps": 12216.73, + "throughput_min_mbps": 11802.28, + "throughput_max_mbps": 12455.73, + "ops_per_sec_avg": 872.62, + "latency_per_key_ms": 1.146 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.cpu new file mode 100644 index 0000000..4232882 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.3957884311676, "user_s": 158.92288, "sys_s": 65.812564, "max_rss_kb": 15058952} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.json new file mode 100644 index 0000000..2168c1b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d2_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 739.46, + "duration_min_ms": 684.2, + "duration_max_ms": 876.93, + "duration_p50_ms": 739.63, + "duration_p99_ms": 876.93, + "duration_std_ms": 38.61, + "throughput_avg_mbps": 9717.32, + "throughput_min_mbps": 8173.94, + "throughput_max_mbps": 10476.48, + "ops_per_sec_avg": 694.09, + "latency_per_key_ms": 1.444 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.28, + "duration_min_ms": 10.04, + "duration_max_ms": 10.71, + "duration_p50_ms": 10.25, + "duration_p99_ms": 10.71, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49806.68, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 593.86, + "duration_min_ms": 584.54, + "duration_max_ms": 608.61, + "duration_p50_ms": 593.5, + "duration_p99_ms": 608.61, + "duration_std_ms": 5.68, + "throughput_avg_mbps": 12071.23, + "throughput_min_mbps": 11777.73, + "throughput_max_mbps": 12262.69, + "ops_per_sec_avg": 862.23, + "latency_per_key_ms": 1.16 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.cpu new file mode 100644 index 0000000..184fe56 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.98317861557007, "user_s": 295.563514, "sys_s": 106.076536, "max_rss_kb": 15061600} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.json new file mode 100644 index 0000000..21efb27 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 395.17, + "duration_min_ms": 365.82, + "duration_max_ms": 458.98, + "duration_p50_ms": 387.62, + "duration_p99_ms": 458.98, + "duration_std_ms": 24.1, + "throughput_avg_mbps": 18202.32, + "throughput_min_mbps": 15617.3, + "throughput_max_mbps": 19594.42, + "ops_per_sec_avg": 1300.17, + "latency_per_key_ms": 0.772 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 9.96, + "duration_min_ms": 8.89, + "duration_max_ms": 11.54, + "duration_p50_ms": 10.24, + "duration_p99_ms": 11.54, + "duration_std_ms": 0.85, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 51773.72, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 311.02, + "duration_min_ms": 304.93, + "duration_max_ms": 320.69, + "duration_p50_ms": 311.28, + "duration_p99_ms": 320.69, + "duration_std_ms": 3.63, + "throughput_avg_mbps": 23049.88, + "throughput_min_mbps": 22351.98, + "throughput_max_mbps": 23506.72, + "ops_per_sec_avg": 1646.42, + "latency_per_key_ms": 0.607 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.cpu new file mode 100644 index 0000000..e542f71 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.359509229660034, "user_s": 296.074243, "sys_s": 106.811256, "max_rss_kb": 15063840} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.json new file mode 100644 index 0000000..760fbc8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 384.57, + "duration_min_ms": 350.4, + "duration_max_ms": 465.5, + "duration_p50_ms": 379.0, + "duration_p99_ms": 465.5, + "duration_std_ms": 20.5, + "throughput_avg_mbps": 18686.03, + "throughput_min_mbps": 15398.51, + "throughput_max_mbps": 20456.76, + "ops_per_sec_avg": 1334.72, + "latency_per_key_ms": 0.751 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 9.31, + "duration_min_ms": 6.55, + "duration_max_ms": 11.68, + "duration_p50_ms": 10.3, + "duration_p99_ms": 11.68, + "duration_std_ms": 1.56, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 56699.62, + "latency_per_key_ms": 0.018 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 311.48, + "duration_min_ms": 302.97, + "duration_max_ms": 322.04, + "duration_p50_ms": 311.83, + "duration_p99_ms": 322.04, + "duration_std_ms": 4.0, + "throughput_avg_mbps": 23016.17, + "throughput_min_mbps": 22257.95, + "throughput_max_mbps": 23658.91, + "ops_per_sec_avg": 1644.01, + "latency_per_key_ms": 0.608 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.cpu new file mode 100644 index 0000000..40b4be9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.06578087806702, "user_s": 296.229143, "sys_s": 107.422838, "max_rss_kb": 15061124} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.json new file mode 100644 index 0000000..94a6431 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w128-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 380.08, + "duration_min_ms": 355.9, + "duration_max_ms": 476.92, + "duration_p50_ms": 379.71, + "duration_p99_ms": 476.92, + "duration_std_ms": 17.21, + "throughput_avg_mbps": 18892.77, + "throughput_min_mbps": 15029.82, + "throughput_max_mbps": 20140.63, + "ops_per_sec_avg": 1349.48, + "latency_per_key_ms": 0.742 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.39, + "duration_min_ms": 9.75, + "duration_max_ms": 12.4, + "duration_p50_ms": 10.26, + "duration_p99_ms": 12.4, + "duration_std_ms": 0.46, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49350.96, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 309.36, + "duration_min_ms": 303.62, + "duration_max_ms": 317.94, + "duration_p50_ms": 308.58, + "duration_p99_ms": 317.94, + "duration_std_ms": 3.43, + "throughput_avg_mbps": 23172.89, + "throughput_min_mbps": 22545.38, + "throughput_max_mbps": 23608.24, + "ops_per_sec_avg": 1655.21, + "latency_per_key_ms": 0.604 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.cpu new file mode 100644 index 0000000..805f081 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.835742235183716, "user_s": 299.664456, "sys_s": 111.94907, "max_rss_kb": 15060856} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.json new file mode 100644 index 0000000..520a419 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 394.05, + "duration_min_ms": 368.28, + "duration_max_ms": 480.71, + "duration_p50_ms": 383.33, + "duration_p99_ms": 480.71, + "duration_std_ms": 23.39, + "throughput_avg_mbps": 18248.15, + "throughput_min_mbps": 14911.38, + "throughput_max_mbps": 19463.62, + "ops_per_sec_avg": 1303.44, + "latency_per_key_ms": 0.77 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.25, + "duration_min_ms": 9.95, + "duration_max_ms": 11.85, + "duration_p50_ms": 11.47, + "duration_p99_ms": 11.85, + "duration_std_ms": 0.58, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 45651.5, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 291.27, + "duration_min_ms": 280.63, + "duration_max_ms": 305.57, + "duration_p50_ms": 289.93, + "duration_p99_ms": 305.57, + "duration_std_ms": 5.82, + "throughput_avg_mbps": 24618.84, + "throughput_min_mbps": 23457.86, + "throughput_max_mbps": 25542.75, + "ops_per_sec_avg": 1758.49, + "latency_per_key_ms": 0.569 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.cpu new file mode 100644 index 0000000..9752c80 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.83384442329407, "user_s": 299.590517, "sys_s": 111.937071, "max_rss_kb": 15059292} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.json new file mode 100644 index 0000000..5ba1d13 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 380.95, + "duration_min_ms": 357.97, + "duration_max_ms": 457.75, + "duration_p50_ms": 380.17, + "duration_p99_ms": 457.75, + "duration_std_ms": 15.01, + "throughput_avg_mbps": 18842.28, + "throughput_min_mbps": 15659.24, + "throughput_max_mbps": 20023.95, + "ops_per_sec_avg": 1345.88, + "latency_per_key_ms": 0.744 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.62, + "duration_min_ms": 9.93, + "duration_max_ms": 12.1, + "duration_p50_ms": 10.36, + "duration_p99_ms": 12.1, + "duration_std_ms": 0.5, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48302.92, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 288.08, + "duration_min_ms": 279.44, + "duration_max_ms": 298.8, + "duration_p50_ms": 288.36, + "duration_p99_ms": 298.8, + "duration_std_ms": 4.45, + "throughput_avg_mbps": 24887.78, + "throughput_min_mbps": 23988.9, + "throughput_max_mbps": 25651.37, + "ops_per_sec_avg": 1777.7, + "latency_per_key_ms": 0.563 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.cpu new file mode 100644 index 0000000..07b7473 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.22753381729126, "user_s": 300.619074, "sys_s": 111.789502, "max_rss_kb": 15056616} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.json new file mode 100644 index 0000000..e2efbba --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 387.09, + "duration_min_ms": 371.34, + "duration_max_ms": 469.96, + "duration_p50_ms": 382.34, + "duration_p99_ms": 469.96, + "duration_std_ms": 17.1, + "throughput_avg_mbps": 18548.84, + "throughput_min_mbps": 15252.25, + "throughput_max_mbps": 19302.85, + "ops_per_sec_avg": 1324.92, + "latency_per_key_ms": 0.756 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.61, + "duration_min_ms": 10.01, + "duration_max_ms": 11.66, + "duration_p50_ms": 10.46, + "duration_p99_ms": 11.66, + "duration_std_ms": 0.42, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48341.05, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 288.1, + "duration_min_ms": 281.85, + "duration_max_ms": 295.48, + "duration_p50_ms": 287.08, + "duration_p99_ms": 295.48, + "duration_std_ms": 3.53, + "throughput_avg_mbps": 24883.78, + "throughput_min_mbps": 24258.64, + "throughput_max_mbps": 25431.82, + "ops_per_sec_avg": 1777.41, + "latency_per_key_ms": 0.563 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.cpu new file mode 100644 index 0000000..dd68b9d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.80859589576721, "user_s": 296.314106, "sys_s": 107.647022, "max_rss_kb": 15061584} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.json new file mode 100644 index 0000000..2bc82be --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 393.07, + "duration_min_ms": 371.7, + "duration_max_ms": 493.11, + "duration_p50_ms": 384.05, + "duration_p99_ms": 493.11, + "duration_std_ms": 21.86, + "throughput_avg_mbps": 18285.86, + "throughput_min_mbps": 14536.21, + "throughput_max_mbps": 19284.21, + "ops_per_sec_avg": 1306.13, + "latency_per_key_ms": 0.768 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.6, + "duration_min_ms": 9.96, + "duration_max_ms": 11.6, + "duration_p50_ms": 10.4, + "duration_p99_ms": 11.6, + "duration_std_ms": 0.45, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48402.94, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 309.3, + "duration_min_ms": 287.82, + "duration_max_ms": 321.88, + "duration_p50_ms": 310.03, + "duration_p99_ms": 321.88, + "duration_std_ms": 6.85, + "throughput_avg_mbps": 23186.18, + "throughput_min_mbps": 22269.38, + "throughput_max_mbps": 24904.33, + "ops_per_sec_avg": 1656.16, + "latency_per_key_ms": 0.604 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.cpu new file mode 100644 index 0000000..6b7e3ff --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.22246217727661, "user_s": 295.69273, "sys_s": 105.926953, "max_rss_kb": 15060952} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.json new file mode 100644 index 0000000..6b15e41 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 385.76, + "duration_min_ms": 358.96, + "duration_max_ms": 503.83, + "duration_p50_ms": 381.03, + "duration_p99_ms": 503.83, + "duration_std_ms": 22.23, + "throughput_avg_mbps": 18633.87, + "throughput_min_mbps": 14226.95, + "throughput_max_mbps": 19968.57, + "ops_per_sec_avg": 1330.99, + "latency_per_key_ms": 0.753 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.53, + "duration_min_ms": 10.01, + "duration_max_ms": 11.74, + "duration_p50_ms": 10.37, + "duration_p99_ms": 11.74, + "duration_std_ms": 0.45, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48704.69, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 307.01, + "duration_min_ms": 297.23, + "duration_max_ms": 324.57, + "duration_p50_ms": 306.72, + "duration_p99_ms": 324.57, + "duration_std_ms": 5.98, + "throughput_avg_mbps": 23356.62, + "throughput_min_mbps": 22084.68, + "throughput_max_mbps": 24116.03, + "ops_per_sec_avg": 1668.33, + "latency_per_key_ms": 0.6 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.cpu new file mode 100644 index 0000000..78bfcf6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.2830765247345, "user_s": 296.455179, "sys_s": 106.340747, "max_rss_kb": 15063132} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.json new file mode 100644 index 0000000..805d90f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_14mib_d4_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 387.56, + "duration_min_ms": 367.62, + "duration_max_ms": 587.24, + "duration_p50_ms": 382.05, + "duration_p99_ms": 587.24, + "duration_std_ms": 32.0, + "throughput_avg_mbps": 18586.15, + "throughput_min_mbps": 12206.24, + "throughput_max_mbps": 19498.51, + "ops_per_sec_avg": 1327.58, + "latency_per_key_ms": 0.757 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.94, + "duration_min_ms": 10.16, + "duration_max_ms": 12.05, + "duration_p50_ms": 10.93, + "duration_p99_ms": 12.05, + "duration_std_ms": 0.49, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46902.81, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 305.32, + "duration_min_ms": 293.93, + "duration_max_ms": 318.06, + "duration_p50_ms": 305.84, + "duration_p99_ms": 318.06, + "duration_std_ms": 5.66, + "throughput_avg_mbps": 23485.27, + "throughput_min_mbps": 22536.67, + "throughput_max_mbps": 24386.97, + "ops_per_sec_avg": 1677.52, + "latency_per_key_ms": 0.596 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.cpu new file mode 100644 index 0000000..ff52665 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.45708632469177, "user_s": 337.309158, "sys_s": 124.550488, "max_rss_kb": 17149484} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.json new file mode 100644 index 0000000..5d68141 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 436.65, + "duration_min_ms": 406.38, + "duration_max_ms": 506.28, + "duration_p50_ms": 428.88, + "duration_p99_ms": 506.28, + "duration_std_ms": 21.4, + "throughput_avg_mbps": 18801.61, + "throughput_min_mbps": 16180.79, + "throughput_max_mbps": 20158.46, + "ops_per_sec_avg": 1175.1, + "latency_per_key_ms": 0.853 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.86, + "duration_min_ms": 9.9, + "duration_max_ms": 12.9, + "duration_p50_ms": 10.48, + "duration_p99_ms": 12.9, + "duration_std_ms": 0.78, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47366.23, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 332.64, + "duration_min_ms": 320.56, + "duration_max_ms": 355.29, + "duration_p50_ms": 331.02, + "duration_p99_ms": 355.29, + "duration_std_ms": 8.06, + "throughput_avg_mbps": 24641.29, + "throughput_min_mbps": 23057.24, + "throughput_max_mbps": 25555.01, + "ops_per_sec_avg": 1540.08, + "latency_per_key_ms": 0.65 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.cpu new file mode 100644 index 0000000..b22322a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.32640528678894, "user_s": 335.83953, "sys_s": 124.465934, "max_rss_kb": 17150068} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.json new file mode 100644 index 0000000..9c97628 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 437.07, + "duration_min_ms": 419.72, + "duration_max_ms": 498.1, + "duration_p50_ms": 435.56, + "duration_p99_ms": 498.1, + "duration_std_ms": 13.33, + "throughput_avg_mbps": 18759.11, + "throughput_min_mbps": 16446.66, + "throughput_max_mbps": 19517.71, + "ops_per_sec_avg": 1172.44, + "latency_per_key_ms": 0.854 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.53, + "duration_min_ms": 8.8, + "duration_max_ms": 11.0, + "duration_p50_ms": 10.57, + "duration_p99_ms": 11.0, + "duration_std_ms": 0.36, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48701.9, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 330.82, + "duration_min_ms": 320.46, + "duration_max_ms": 348.44, + "duration_p50_ms": 330.71, + "duration_p99_ms": 348.44, + "duration_std_ms": 4.97, + "throughput_avg_mbps": 24768.3, + "throughput_min_mbps": 23510.26, + "throughput_max_mbps": 25563.6, + "ops_per_sec_avg": 1548.02, + "latency_per_key_ms": 0.646 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.cpu new file mode 100644 index 0000000..59671cf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.58036971092224, "user_s": 337.317285, "sys_s": 123.660994, "max_rss_kb": 17150900} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.json new file mode 100644 index 0000000..aad137a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_16mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 438.49, + "duration_min_ms": 412.84, + "duration_max_ms": 528.37, + "duration_p50_ms": 434.14, + "duration_p99_ms": 528.37, + "duration_std_ms": 20.27, + "throughput_avg_mbps": 18716.96, + "throughput_min_mbps": 15504.28, + "throughput_max_mbps": 19843.26, + "ops_per_sec_avg": 1169.81, + "latency_per_key_ms": 0.856 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.12, + "duration_min_ms": 9.98, + "duration_max_ms": 11.93, + "duration_p50_ms": 11.18, + "duration_p99_ms": 11.93, + "duration_std_ms": 0.41, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46105.93, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 332.45, + "duration_min_ms": 322.3, + "duration_max_ms": 343.99, + "duration_p50_ms": 332.01, + "duration_p99_ms": 343.99, + "duration_std_ms": 4.98, + "throughput_avg_mbps": 24646.41, + "throughput_min_mbps": 23814.45, + "throughput_max_mbps": 25417.29, + "ops_per_sec_avg": 1540.4, + "latency_per_key_ms": 0.649 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.cpu new file mode 100644 index 0000000..f6f9291 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.260859251022339, "user_s": 96.430224, "sys_s": 31.647271, "max_rss_kb": 2468480} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.json new file mode 100644 index 0000000..07f5805 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 71.41, + "duration_min_ms": 52.93, + "duration_max_ms": 182.92, + "duration_p50_ms": 66.54, + "duration_p99_ms": 182.92, + "duration_std_ms": 21.7, + "throughput_avg_mbps": 15277.92, + "throughput_min_mbps": 5597.94, + "throughput_max_mbps": 19347.49, + "ops_per_sec_avg": 7638.96, + "latency_per_key_ms": 0.139 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 10.51, + "duration_min_ms": 9.91, + "duration_max_ms": 11.79, + "duration_p50_ms": 10.34, + "duration_p99_ms": 11.79, + "duration_std_ms": 0.49, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48807.67, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 41.47, + "duration_min_ms": 40.51, + "duration_max_ms": 42.5, + "duration_p50_ms": 41.37, + "duration_p99_ms": 42.5, + "duration_std_ms": 0.47, + "throughput_avg_mbps": 24695.32, + "throughput_min_mbps": 24091.5, + "throughput_max_mbps": 25276.61, + "ops_per_sec_avg": 12347.66, + "latency_per_key_ms": 0.081 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.cpu new file mode 100644 index 0000000..f1c2739 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.17509651184082, "user_s": 92.876081, "sys_s": 31.430674, "max_rss_kb": 2467584} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.json new file mode 100644 index 0000000..f366a17 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 70.71, + "duration_min_ms": 52.11, + "duration_max_ms": 180.09, + "duration_p50_ms": 64.88, + "duration_p99_ms": 180.09, + "duration_std_ms": 21.14, + "throughput_avg_mbps": 15389.52, + "throughput_min_mbps": 5686.02, + "throughput_max_mbps": 19649.14, + "ops_per_sec_avg": 7694.76, + "latency_per_key_ms": 0.138 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 10.66, + "duration_min_ms": 8.73, + "duration_max_ms": 12.4, + "duration_p50_ms": 10.51, + "duration_p99_ms": 12.4, + "duration_std_ms": 0.65, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48199.72, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 41.63, + "duration_min_ms": 40.5, + "duration_max_ms": 44.26, + "duration_p50_ms": 41.5, + "duration_p99_ms": 44.26, + "duration_std_ms": 0.76, + "throughput_avg_mbps": 24604.27, + "throughput_min_mbps": 23135.79, + "throughput_max_mbps": 25286.0, + "ops_per_sec_avg": 12302.13, + "latency_per_key_ms": 0.081 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.cpu new file mode 100644 index 0000000..8d6a4fa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 14.101169109344482, "user_s": 91.815715, "sys_s": 27.233736, "max_rss_kb": 2470368} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.json new file mode 100644 index 0000000..f54bfd3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed/fix_2mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 2048, + "data_per_round_mb": 1024.0, + "measurement_rounds": 64, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 70.4, + "duration_min_ms": 51.73, + "duration_max_ms": 183.64, + "duration_p50_ms": 63.71, + "duration_p99_ms": 183.64, + "duration_std_ms": 21.2, + "throughput_avg_mbps": 15441.31, + "throughput_min_mbps": 5576.03, + "throughput_max_mbps": 19796.12, + "ops_per_sec_avg": 7720.66, + "latency_per_key_ms": 0.137 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 0, + "duration_avg_ms": 10.68, + "duration_min_ms": 9.53, + "duration_max_ms": 12.91, + "duration_p50_ms": 10.33, + "duration_p99_ms": 12.91, + "duration_std_ms": 1.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48328.79, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 32768, + "total_success": 32768, + "duration_avg_ms": 41.63, + "duration_min_ms": 40.59, + "duration_max_ms": 44.64, + "duration_p50_ms": 41.39, + "duration_p99_ms": 44.64, + "duration_std_ms": 0.82, + "throughput_avg_mbps": 24608.92, + "throughput_min_mbps": 22936.77, + "throughput_max_mbps": 25227.28, + "ops_per_sec_avg": 12304.46, + "latency_per_key_ms": 0.081 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_base.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_base.txt new file mode 100644 index 0000000..ace452a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_base.txt @@ -0,0 +1,407 @@ +Linux 6.8.0-147-generic (node) 11/04/2026 _x86_64_ (96 CPU) + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 10340.16 1282.30 13.80 0.13 33.12 126.99 10203.49 1260.86 11.26 0.11 40.52 126.54 17.92 57635.16 0.00 0.00 204.85 3293519.65 0.00 0.00 759.57 52.09 +nvme2n1 5532.70 682.97 11.71 0.21 34.31 126.41 5470.84 672.97 9.53 0.17 43.33 125.96 17.92 57635.16 0.00 0.00 221.69 3293519.65 0.00 0.00 430.87 29.26 +nvme3n1 3066.50 378.93 4.20 0.14 6.48 126.54 3089.95 380.65 3.57 0.12 8.89 126.15 16.00 53705.61 0.00 0.00 215.66 3437112.90 0.00 0.00 50.78 17.66 +nvme4n1 2562.67 315.90 4.90 0.19 6.51 126.23 2585.30 317.59 3.96 0.15 8.29 125.79 16.00 53705.61 0.00 0.00 216.93 3437112.90 0.00 0.00 41.59 16.03 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 57.00 1.09 0.00 0.00 0.42 19.58 10728.00 1340.25 0.00 0.00 11.40 127.93 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 122.35 27.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 9975.00 1246.12 0.00 0.00 8.22 127.92 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 81.95 26.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 9807.00 1224.12 1.00 0.01 1.39 127.82 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 13.63 25.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 4880.00 610.00 1.00 0.02 0.15 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.71 11.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36902.00 4611.00 0.00 0.00 13.04 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 481.32 95.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37415.00 4675.38 0.00 0.00 5.59 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 208.96 91.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37561.00 4691.25 2.00 0.01 0.79 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 29.80 87.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18763.00 2345.38 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.68 39.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37488.00 4683.25 0.00 0.00 6.92 127.92 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 259.38 90.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37553.00 4692.00 0.00 0.00 10.81 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 406.12 93.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37573.00 4691.00 3.00 0.01 1.54 127.85 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 58.02 92.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18772.00 2346.62 3.00 0.02 0.14 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.69 44.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34117.00 4262.88 0.00 0.00 12.60 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 430.01 87.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 33605.00 4199.12 0.00 0.00 7.11 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 239.04 91.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 33419.00 4173.62 2.00 0.01 1.35 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 45.02 77.40 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 16705.00 2088.00 2.00 0.01 0.14 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.40 38.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 33120.00 4138.25 0.00 0.00 2.13 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 70.55 77.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 33065.00 4131.62 0.00 0.00 18.01 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 595.35 95.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 33187.00 4144.62 2.00 0.01 1.60 127.88 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 53.09 80.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 16560.00 2070.00 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.37 36.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37705.00 4711.38 0.00 0.00 6.59 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 248.35 97.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38380.00 4796.00 0.00 0.00 5.93 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 227.41 90.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37888.00 4732.25 2.00 0.01 7.54 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 285.51 95.40 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18848.00 2356.00 2.00 0.01 0.15 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.79 41.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35714.00 4462.50 0.00 0.00 3.92 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 139.99 85.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35563.00 4443.75 0.00 0.00 10.81 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 384.28 93.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36219.00 4523.75 2.00 0.01 5.08 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 184.06 87.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18176.00 2272.00 2.00 0.01 0.16 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.82 42.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37616.00 4699.38 0.00 0.00 6.96 127.93 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 261.99 90.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37304.00 4660.88 0.00 0.00 10.99 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 410.03 92.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37320.00 4659.25 3.00 0.01 1.09 127.84 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 40.82 85.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18640.00 2330.00 3.00 0.02 0.15 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.72 40.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35655.00 4455.12 0.00 0.00 8.35 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 297.71 85.60 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35591.00 4447.38 0.00 0.00 9.87 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 351.39 94.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35311.00 4410.12 2.00 0.01 2.11 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 74.58 87.40 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17646.00 2205.75 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.49 40.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38772.00 4844.75 0.00 0.00 8.03 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 311.42 92.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38788.00 4846.88 0.00 0.00 7.01 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 272.08 90.50 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38787.00 4844.62 2.00 0.01 3.61 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 139.85 92.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 19376.00 2422.00 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.75 46.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35773.00 4469.88 0.00 0.00 9.84 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 351.89 89.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36069.00 4507.12 0.00 0.00 8.29 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 299.13 92.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36394.00 4545.62 2.00 0.01 1.27 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 46.36 88.20 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18177.00 2272.25 2.00 0.01 0.14 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.55 40.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36219.00 4525.62 0.00 0.00 7.79 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 282.23 84.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36442.00 4553.75 0.00 0.00 10.28 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 374.47 92.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36509.00 4559.75 2.00 0.01 2.27 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 82.87 85.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18257.00 2282.00 2.00 0.01 0.14 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.62 40.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37574.00 4694.38 0.00 0.00 12.64 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 475.11 96.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37341.00 4665.50 0.00 0.00 4.71 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 175.71 88.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37357.00 4664.00 3.00 0.01 1.72 127.85 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 64.28 87.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18656.00 2332.00 3.00 0.02 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.64 41.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36124.00 4513.50 0.00 0.00 6.37 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 230.21 83.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36129.00 4514.50 0.00 0.00 11.26 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 406.95 92.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36111.00 4510.12 2.00 0.01 1.84 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.53 85.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18030.00 2253.75 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.60 38.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38129.00 4764.38 0.00 0.00 13.59 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 518.29 97.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38073.00 4757.62 0.00 0.00 3.82 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 145.44 87.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37784.00 4719.25 2.00 0.01 1.61 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 60.68 87.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18866.00 2358.25 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.68 42.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 33514.00 4187.50 0.00 0.00 2.53 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 84.73 79.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 33044.00 4129.00 0.00 0.00 14.74 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 487.23 92.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 33259.00 4153.62 2.00 0.01 5.43 127.88 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 180.55 85.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 16619.00 2077.38 2.00 0.01 0.15 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.43 34.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38277.00 4782.00 0.00 0.00 12.64 127.93 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 483.83 96.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38415.00 4799.88 0.00 0.00 4.82 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 185.33 90.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38433.00 4798.50 3.00 0.01 1.53 127.85 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 58.72 88.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 19189.00 2398.62 3.00 0.02 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.74 43.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34812.00 4349.75 0.00 0.00 8.77 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 305.41 88.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34964.00 4368.88 0.00 0.00 9.66 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 337.58 91.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34994.00 4370.62 2.00 0.01 2.32 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 81.19 85.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17487.00 2186.00 2.00 0.01 0.14 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.49 41.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38639.00 4828.12 0.00 0.00 9.26 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 357.95 93.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38467.00 4806.88 0.00 0.00 6.87 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 264.27 90.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38369.00 4792.38 2.00 0.01 2.97 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 113.79 90.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 19169.00 2396.00 2.00 0.01 0.14 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.71 42.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35007.00 4374.25 0.00 0.00 11.01 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 385.42 91.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35451.00 4429.75 0.00 0.00 7.96 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 282.05 90.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35695.00 4458.00 2.00 0.01 1.60 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 56.96 85.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17837.00 2229.62 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.48 41.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36081.00 4507.75 0.00 0.00 9.20 127.93 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 331.98 85.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36174.00 4520.12 0.00 0.00 8.57 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 310.15 91.60 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36206.00 4521.27 3.00 0.01 1.18 127.87 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 42.73 86.20 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18083.00 2260.38 3.00 0.02 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.59 40.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35074.00 4382.12 0.00 0.00 10.75 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 377.05 93.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34867.00 4356.50 0.00 0.00 7.17 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 250.02 87.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34835.00 4349.48 2.00 0.01 2.39 127.86 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 83.20 81.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17392.00 2174.00 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.45 37.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36358.00 4543.12 0.00 0.00 7.18 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 261.19 86.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35966.00 4494.12 0.00 0.00 10.10 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 363.31 92.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35893.00 4483.00 2.00 0.01 2.76 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 99.22 87.20 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17935.00 2242.00 2.00 0.01 0.14 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.53 39.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36901.00 4610.88 0.00 0.00 14.70 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 542.58 98.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37396.00 4672.88 0.00 0.00 3.92 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 146.56 88.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37497.00 4683.25 2.00 0.01 0.95 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 35.73 87.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18725.00 2340.50 2.00 0.01 0.14 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.67 41.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 32831.00 4102.12 0.00 0.00 4.64 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 152.42 74.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 32384.00 4046.50 0.00 0.00 12.77 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 413.47 91.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 32265.00 4029.38 2.00 0.01 3.81 127.88 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.07 78.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 16124.00 2015.50 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.31 34.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37090.00 4634.38 0.00 0.00 15.35 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 569.51 97.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37439.00 4678.38 0.00 0.00 3.83 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 143.37 87.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37648.00 4702.25 2.00 0.01 0.93 127.90 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 35.16 87.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18812.00 2351.50 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.71 41.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34458.00 4305.50 0.00 0.00 7.99 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 275.21 83.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34760.00 4343.50 0.00 0.00 7.25 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 251.90 86.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34821.00 4348.88 2.00 0.01 4.23 127.89 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 147.14 87.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 17412.00 2176.50 2.00 0.01 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.48 40.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39485.00 4935.75 0.00 0.00 7.27 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 287.24 79.00 +nvme2n1 38886.00 4860.38 0.00 0.00 5.01 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 194.90 78.20 +nvme3n1 38665.00 4833.12 0.00 0.00 1.49 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 57.73 78.60 +nvme4n1 19302.00 2412.75 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.63 66.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39681.00 4960.00 0.00 0.00 6.28 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 249.34 80.70 +nvme2n1 39808.00 4975.75 0.00 0.00 6.30 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 250.94 81.30 +nvme3n1 39718.00 4964.75 0.00 0.00 1.73 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 68.74 80.30 +nvme4n1 19835.00 2479.38 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.94 67.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 35590.00 4448.75 0.00 0.00 7.01 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 249.48 91.10 +nvme2n1 36001.00 4499.88 0.00 0.00 5.11 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 183.81 72.20 +nvme3n1 36305.00 4538.12 0.00 0.00 1.90 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 69.06 73.10 +nvme4n1 18207.00 2275.88 0.00 0.00 0.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.80 62.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39799.00 4975.00 0.00 0.00 3.86 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 153.51 89.30 +nvme2n1 39246.00 4905.38 0.00 0.00 8.50 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 333.60 81.10 +nvme3n1 39003.00 4875.38 0.00 0.00 1.76 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 68.70 80.50 +nvme4n1 19488.00 2436.00 0.00 0.00 0.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.58 66.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39654.00 4956.62 0.00 0.00 3.23 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.23 89.40 +nvme2n1 40214.00 5026.62 0.00 0.00 5.24 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 210.76 79.80 +nvme3n1 39794.00 4974.25 0.00 0.00 5.58 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 222.16 82.00 +nvme4n1 19794.00 2474.25 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.97 66.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 35598.00 4449.75 0.00 0.00 4.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 166.80 80.40 +nvme2n1 35364.00 4420.12 0.00 0.00 6.89 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 243.71 71.40 +nvme3n1 35955.00 4494.38 0.00 0.00 2.77 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 99.77 73.10 +nvme4n1 18078.00 2259.75 0.00 0.00 0.62 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.19 60.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40821.00 5102.62 0.00 0.00 6.10 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 249.04 90.40 +nvme2n1 40612.00 5076.12 0.00 0.00 5.78 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 234.88 81.60 +nvme3n1 40358.00 5044.75 0.00 0.00 1.94 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 78.16 81.30 +nvme4n1 20145.00 2518.12 0.00 0.00 0.61 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.29 69.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40132.00 5016.50 0.00 0.00 7.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 308.03 90.90 +nvme2n1 40382.00 5047.50 0.00 0.00 4.47 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 180.56 81.10 +nvme3n1 40561.00 5070.12 0.00 0.00 1.65 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.88 81.60 +nvme4n1 20317.00 2539.62 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.16 68.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36087.00 4510.88 0.00 0.00 6.16 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 222.45 81.80 +nvme2n1 35907.00 4488.00 0.00 0.00 5.94 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 213.12 72.00 +nvme3n1 35853.00 4481.62 0.00 0.00 1.85 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.32 72.00 +nvme4n1 17894.00 2236.88 0.00 0.00 0.61 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.88 60.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39908.00 4988.50 0.00 0.00 9.20 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 367.28 91.10 +nvme2n1 40072.00 5008.75 0.00 0.00 3.03 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 121.37 81.20 +nvme3n1 40124.00 5015.62 0.00 0.00 1.75 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 70.24 81.40 +nvme4n1 20060.00 2507.38 0.00 0.00 0.61 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.16 68.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39229.00 4903.62 0.00 0.00 6.64 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 260.64 78.70 +nvme2n1 39518.00 4939.50 0.00 0.00 5.24 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 207.05 79.30 +nvme3n1 39648.00 4955.88 0.00 0.00 1.67 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.27 79.80 +nvme4n1 19872.00 2484.00 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.97 67.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37350.00 4668.75 0.00 0.00 6.82 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 254.67 84.00 +nvme2n1 36796.00 4599.12 0.00 0.00 5.49 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 201.91 74.40 +nvme3n1 36598.00 4574.75 0.00 0.00 1.70 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 62.10 73.90 +nvme4n1 18256.00 2282.00 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.96 62.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40802.00 5100.25 0.00 0.00 6.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 272.59 91.00 +nvme2n1 41132.00 5141.25 0.00 0.00 5.33 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 219.19 82.00 +nvme3n1 41078.00 5134.75 0.00 0.00 1.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 69.23 82.20 +nvme4n1 20535.00 2566.88 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.38 70.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36536.00 4567.00 0.00 0.00 7.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 267.84 74.00 +nvme2n1 36767.00 4595.62 0.00 0.00 4.92 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 180.81 73.80 +nvme3n1 37012.00 4626.50 0.00 0.00 1.75 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 64.75 74.80 +nvme4n1 18553.00 2319.12 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.19 63.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39661.00 4957.62 0.00 0.00 6.80 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 269.58 88.80 +nvme2n1 39435.00 4929.00 0.00 0.00 5.22 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 205.78 79.30 +nvme3n1 39279.00 4909.88 0.00 0.00 1.84 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 72.39 79.20 +nvme4n1 19600.00 2450.00 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.82 67.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40494.00 5061.75 0.00 0.00 6.12 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 247.81 90.00 +nvme2n1 40502.00 5062.50 0.00 0.00 5.68 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 229.94 81.40 +nvme3n1 40391.00 5048.88 0.00 0.00 1.83 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 73.81 81.70 +nvme4n1 20192.00 2524.00 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.21 70.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36391.00 4548.88 0.00 0.00 8.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 302.17 73.00 +nvme2n1 36354.00 4543.88 0.00 0.00 3.43 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.52 72.50 +nvme3n1 36470.00 4558.75 0.00 0.00 1.83 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.71 73.30 +nvme4n1 18240.00 2280.00 0.00 0.00 0.61 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.04 62.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40097.00 5012.25 0.00 0.00 8.16 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 327.15 81.10 +nvme2n1 40073.00 5008.88 0.00 0.00 3.95 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 158.32 81.20 +nvme3n1 39995.00 4999.38 0.00 0.00 1.63 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 65.28 81.90 +nvme4n1 19980.00 2497.50 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.08 68.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39965.00 4995.50 0.00 0.00 7.07 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 282.72 81.20 +nvme2n1 40254.00 5031.50 0.00 0.00 4.81 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 193.75 81.30 +nvme3n1 40198.00 5024.75 0.00 0.00 1.86 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 74.70 81.50 +nvme4n1 20111.00 2513.88 0.00 0.00 0.61 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.20 70.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 35530.00 4441.25 0.00 0.00 7.46 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 265.15 82.30 +nvme2n1 35273.00 4408.75 0.00 0.00 5.16 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 182.04 71.30 +nvme3n1 35385.00 4423.12 0.00 0.00 1.54 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 54.42 72.50 +nvme4n1 17685.00 2210.62 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.53 61.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40425.00 5053.12 0.00 0.00 6.37 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 257.62 90.70 +nvme2n1 40249.00 5031.00 0.00 0.00 5.78 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 232.74 81.80 +nvme3n1 40168.00 5021.00 0.00 0.00 1.77 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 71.07 81.60 +nvme4n1 20082.00 2510.25 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.05 69.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38733.00 4841.62 0.00 0.00 10.27 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 397.65 89.90 +nvme2n1 39175.00 4896.50 0.00 0.00 1.98 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 77.38 79.70 +nvme3n1 39410.00 4926.25 0.00 0.00 1.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 62.85 80.30 +nvme4n1 19758.00 2469.75 0.00 0.00 0.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.64 66.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 35905.00 4488.12 0.00 0.00 6.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 225.92 81.50 +nvme2n1 35692.00 4461.25 0.00 0.00 6.48 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 231.44 73.30 +nvme3n1 35535.00 4441.88 0.00 0.00 1.46 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 51.79 73.10 +nvme4n1 17712.00 2214.00 0.00 0.00 0.58 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.36 63.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40551.00 5068.88 0.00 0.00 8.76 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 355.24 99.70 +nvme2n1 40280.00 5034.75 0.00 0.00 3.27 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.80 81.90 +nvme3n1 40114.00 5014.25 0.00 0.00 1.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 67.77 81.80 +nvme4n1 20064.00 2508.00 0.00 0.00 0.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.83 68.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 21848.00 2731.00 0.00 0.00 6.04 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.98 44.00 +nvme2n1 22338.00 2792.00 0.00 0.00 6.12 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.81 44.80 +nvme3n1 22655.00 2831.88 0.00 0.00 1.79 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 40.62 45.50 +nvme4n1 11376.00 1422.00 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 6.78 37.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 49.00 1.04 0.00 0.00 0.08 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.10 +nvme2n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.30 +nvme3n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.20 +nvme4n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.40 + diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_fix.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_fix.txt new file mode 100644 index 0000000..897d528 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/fixed_iostat_fix.txt @@ -0,0 +1,358 @@ +Linux 6.8.0-147-generic (node) 11/04/2026 _x86_64_ (96 CPU) + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 10494.68 1302.33 12.80 0.12 31.53 127.07 10367.85 1282.44 10.47 0.10 38.35 126.66 17.66 57699.80 0.00 0.00 208.37 3346310.92 0.00 0.00 20.00 52.80 +nvme2n1 5906.02 730.23 10.86 0.18 30.49 126.61 5848.63 720.95 8.84 0.15 38.80 126.23 17.66 57699.80 0.00 0.00 223.97 3346310.92 0.00 0.00 410.97 30.91 +nvme3n1 3496.63 432.99 3.90 0.11 5.82 126.80 3518.40 434.59 3.32 0.09 8.19 126.48 15.88 54055.72 0.00 0.00 218.59 3486426.78 0.00 0.00 52.64 19.58 +nvme4n1 2871.85 354.84 4.54 0.16 5.73 126.53 2892.70 356.41 3.68 0.13 7.29 126.17 15.88 54055.72 0.00 0.00 219.40 3486426.78 0.00 0.00 41.03 17.53 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 12004.00 1500.12 0.00 0.00 2.91 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 34.97 28.50 +nvme2n1 51.00 1.04 0.00 0.00 0.27 20.94 11530.00 1441.12 0.00 0.00 5.38 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 62.08 30.60 +nvme3n1 51.00 1.04 0.00 0.00 0.18 20.94 11519.00 1439.62 0.00 0.00 1.88 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 21.64 28.20 +nvme4n1 51.00 1.04 0.00 0.00 0.39 20.94 11774.00 1471.50 0.00 0.00 8.74 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 102.95 30.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35480.00 4434.12 0.00 0.00 4.08 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 144.89 88.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36162.00 4519.62 0.00 0.00 6.17 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 223.08 93.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36107.00 4512.62 0.00 0.00 5.11 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 184.54 91.20 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35720.00 4464.25 0.00 0.00 3.83 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.63 86.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38080.00 4759.50 0.00 0.00 2.61 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 99.33 90.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37584.00 4697.50 0.00 0.00 5.26 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 197.85 90.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37596.00 4699.00 0.00 0.00 3.85 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 144.84 90.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37816.00 4726.50 0.00 0.00 5.90 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 223.07 92.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36591.00 4573.12 0.00 0.00 1.99 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 72.84 91.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36424.00 4552.25 0.00 0.00 4.04 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 147.31 92.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36603.00 4574.75 0.00 0.00 7.14 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 261.32 93.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36733.00 4590.75 0.00 0.00 5.07 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 186.28 91.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34257.00 4281.75 0.00 0.00 1.83 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 62.68 79.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34682.00 4334.62 0.00 0.00 12.46 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 432.29 96.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34333.00 4291.25 0.00 0.00 1.64 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 56.42 80.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 34229.00 4278.00 0.00 0.00 3.65 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.80 79.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37531.00 4690.62 0.00 0.00 2.78 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 104.15 93.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37931.00 4740.62 0.00 0.00 4.34 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 164.66 91.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38300.00 4786.88 0.00 0.00 5.55 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 212.50 96.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37653.00 4706.00 0.00 0.00 5.29 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 199.20 95.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36092.00 4510.88 0.00 0.00 1.95 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 70.40 83.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35957.00 4493.88 0.00 0.00 8.09 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 290.98 92.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35879.00 4483.75 0.00 0.00 4.50 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 161.34 86.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36136.00 4516.38 0.00 0.00 3.42 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.62 84.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36492.00 4560.75 0.00 0.00 3.66 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.45 93.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36646.00 4580.38 0.00 0.00 1.67 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 61.04 86.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36838.00 4604.12 0.00 0.00 3.75 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 138.15 87.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36384.00 4547.62 0.00 0.00 9.43 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 343.15 97.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34540.00 4316.88 0.00 0.00 1.15 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 39.87 79.80 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34391.00 4298.38 0.00 0.00 9.49 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 326.31 94.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34165.00 4270.25 0.00 0.00 4.68 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 160.06 85.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 34641.00 4329.38 0.00 0.00 3.69 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.65 81.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 38727.00 4840.50 0.00 0.00 2.76 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 106.83 96.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 38360.00 4794.12 0.00 0.00 2.57 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 98.40 89.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38413.00 4801.00 0.00 0.00 3.88 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 149.20 92.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 38526.00 4815.00 0.00 0.00 8.48 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 326.68 97.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35564.00 4444.50 0.00 0.00 1.80 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 63.99 85.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36276.00 4534.00 0.00 0.00 8.79 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 318.79 94.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36039.00 4504.12 0.00 0.00 3.34 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 120.44 88.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35779.00 4471.62 0.00 0.00 4.52 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 161.83 87.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36828.00 4603.25 0.00 0.00 2.85 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 104.85 89.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36108.00 4512.62 0.00 0.00 5.71 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 206.24 90.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36297.00 4536.62 0.00 0.00 3.55 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.74 86.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36633.00 4578.62 0.00 0.00 6.04 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 221.41 90.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35258.00 4406.50 0.00 0.00 1.34 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 47.19 85.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35899.00 4486.62 0.00 0.00 6.06 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 217.71 91.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35428.00 4427.88 0.00 0.00 4.92 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 174.48 91.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35196.00 4398.62 0.00 0.00 6.36 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 223.80 89.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 35777.00 4471.50 0.00 0.00 2.38 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 85.25 86.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35190.00 4398.38 0.00 0.00 7.45 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 262.18 91.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35526.00 4440.50 0.00 0.00 2.84 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 100.74 81.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35790.00 4473.12 0.00 0.00 5.83 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 208.52 85.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37377.00 4671.62 0.00 0.00 2.54 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 94.97 93.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37847.00 4729.88 0.00 0.00 3.87 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 146.54 90.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 38233.00 4778.12 0.00 0.00 6.17 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 235.88 96.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37590.00 4698.12 0.00 0.00 5.44 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 204.36 95.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36216.00 4526.38 0.00 0.00 2.70 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 97.69 83.80 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36024.00 4502.62 0.00 0.00 9.80 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 352.86 94.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35324.00 4415.12 0.00 0.00 1.75 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 61.68 84.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35940.00 4491.88 0.00 0.00 4.16 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 149.69 83.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36371.00 4545.88 0.00 0.00 4.30 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 156.51 93.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36499.00 4561.38 0.00 0.00 1.15 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 42.08 85.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37124.00 4639.62 0.00 0.00 5.62 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 208.48 90.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36933.00 4616.00 0.00 0.00 7.12 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 262.84 94.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36231.00 4528.38 0.00 0.00 2.62 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 94.83 86.80 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36285.00 4535.25 0.00 0.00 8.54 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 309.75 95.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36048.00 4505.62 0.00 0.00 4.70 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 169.35 88.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35982.00 4497.12 0.00 0.00 2.32 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 83.52 85.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37648.00 4705.25 0.00 0.00 4.89 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 184.27 95.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37330.00 4665.38 0.00 0.00 2.08 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 77.77 87.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37565.00 4694.88 0.00 0.00 3.30 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.92 89.40 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37667.00 4707.75 0.00 0.00 7.93 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 298.75 97.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 34534.00 4316.12 0.00 0.00 1.20 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 41.32 80.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 34885.00 4360.25 0.00 0.00 7.94 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 277.04 91.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 34885.00 4360.25 0.00 0.00 6.84 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 238.76 89.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 34513.00 4313.38 0.00 0.00 2.60 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 89.67 81.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37221.00 4652.00 0.00 0.00 3.55 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.08 90.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36747.00 4592.50 0.00 0.00 3.92 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 143.88 87.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36518.00 4564.00 0.00 0.00 3.50 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.64 87.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37001.00 4624.50 0.00 0.00 6.78 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 250.81 93.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 33047.00 4130.38 0.00 0.00 1.80 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 59.40 80.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 33731.00 4215.88 0.00 0.00 5.76 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 194.30 85.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 33872.00 4233.50 0.00 0.00 6.33 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 214.49 85.40 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 33134.00 4141.12 0.00 0.00 4.25 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 140.71 82.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36183.00 4522.00 0.00 0.00 3.01 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 108.93 87.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35598.00 4449.12 0.00 0.00 4.81 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 171.14 86.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35453.00 4430.62 0.00 0.00 2.30 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 81.50 82.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36047.00 4505.50 0.00 0.00 7.97 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 287.29 90.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 23361.00 2920.00 0.00 0.00 4.18 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 97.62 57.50 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 23712.00 2963.62 0.00 0.00 8.70 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 206.24 63.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 23729.00 2965.88 0.00 0.00 3.29 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 77.97 60.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 23597.00 2949.25 0.00 0.00 2.51 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 59.26 57.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 13924.00 1740.50 0.00 0.00 1.95 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 27.12 135.10 +nvme2n1 13728.00 1716.00 0.00 0.00 3.05 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 41.83 27.60 +nvme3n1 13787.00 1723.38 0.00 0.00 2.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 32.14 27.70 +nvme4n1 13865.00 1733.12 0.00 0.00 4.46 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 61.87 27.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38081.00 4760.12 0.00 0.00 2.40 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 91.47 75.20 +nvme2n1 38352.00 4794.00 0.00 0.00 3.38 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.78 75.90 +nvme3n1 38065.00 4758.12 0.00 0.00 3.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.52 75.60 +nvme4n1 38007.00 4750.88 0.00 0.00 2.84 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 108.12 75.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37127.00 4640.88 0.00 0.00 2.08 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 77.30 74.50 +nvme2n1 37255.00 4656.88 0.00 0.00 3.72 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 138.70 75.00 +nvme3n1 37461.00 4682.62 0.00 0.00 3.13 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 117.18 75.00 +nvme4n1 37338.00 4667.25 0.00 0.00 3.37 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.80 75.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39828.00 4978.50 0.00 0.00 2.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 91.14 79.50 +nvme2n1 39753.00 4969.12 0.00 0.00 3.55 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 141.05 80.00 +nvme3n1 39775.00 4971.88 0.00 0.00 3.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 146.90 79.90 +nvme4n1 39750.00 4968.75 0.00 0.00 2.37 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 94.20 79.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39432.00 4929.00 0.00 0.00 2.28 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 89.97 78.70 +nvme2n1 39471.00 4934.00 0.00 0.00 4.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 184.90 79.30 +nvme3n1 39451.00 4931.38 0.00 0.00 2.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 84.30 87.20 +nvme4n1 39380.00 4922.50 0.00 0.00 3.01 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 118.51 79.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37770.00 4721.38 0.00 0.00 2.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 86.32 75.50 +nvme2n1 37751.00 4718.75 0.00 0.00 2.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 97.82 83.20 +nvme3n1 37838.00 4729.75 0.00 0.00 2.89 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 109.17 75.00 +nvme4n1 37929.00 4741.12 0.00 0.00 3.92 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 148.79 75.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37422.00 4677.62 0.00 0.00 2.09 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 78.15 75.20 +nvme2n1 37530.00 4691.25 0.00 0.00 4.06 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 152.20 83.40 +nvme3n1 37463.00 4682.88 0.00 0.00 2.77 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 103.60 75.30 +nvme4n1 37315.00 4664.38 0.00 0.00 2.81 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 104.83 75.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 41335.00 5166.88 0.00 0.00 2.22 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 91.88 83.10 +nvme2n1 41220.00 5152.62 0.00 0.00 3.57 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 147.10 83.60 +nvme3n1 41261.00 5157.62 0.00 0.00 2.66 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 109.67 83.60 +nvme4n1 41275.00 5159.38 0.00 0.00 3.48 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 143.82 83.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37660.00 4707.50 0.00 0.00 2.27 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 85.66 75.40 +nvme2n1 38015.00 4751.75 0.00 0.00 3.47 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.80 75.70 +nvme3n1 38042.00 4755.25 0.00 0.00 3.35 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.58 75.80 +nvme4n1 37617.00 4702.12 0.00 0.00 2.56 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 96.36 75.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36525.00 4565.75 0.00 0.00 2.17 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 79.19 74.40 +nvme2n1 36412.00 4551.50 0.00 0.00 4.36 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 158.77 74.90 +nvme3n1 36338.00 4542.25 0.00 0.00 2.24 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 81.53 74.90 +nvme4n1 36643.00 4580.38 0.00 0.00 3.35 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 122.82 75.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 42020.00 5252.38 0.00 0.00 2.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 97.22 83.40 +nvme2n1 41920.00 5240.00 0.00 0.00 2.91 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 121.81 83.00 +nvme3n1 41908.00 5238.50 0.00 0.00 2.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 112.58 83.30 +nvme4n1 41954.00 5244.25 0.00 0.00 3.67 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 154.03 83.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37247.00 4655.88 0.00 0.00 2.20 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 81.96 74.20 +nvme2n1 37406.00 4675.75 0.00 0.00 4.86 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 181.71 83.80 +nvme3n1 37460.00 4682.50 0.00 0.00 2.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 87.83 75.00 +nvme4n1 37223.00 4652.88 0.00 0.00 2.51 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 93.51 75.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36989.00 4623.62 0.00 0.00 2.04 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 75.56 74.50 +nvme2n1 36754.00 4594.25 0.00 0.00 2.38 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 87.54 74.80 +nvme3n1 36811.00 4601.38 0.00 0.00 3.36 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.59 74.50 +nvme4n1 37083.00 4635.38 0.00 0.00 4.04 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 149.87 74.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40608.00 5076.00 0.00 0.00 2.15 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 87.35 81.00 +nvme2n1 40657.00 5082.12 0.00 0.00 4.11 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 167.04 81.40 +nvme3n1 40564.00 5070.50 0.00 0.00 2.73 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 110.84 81.10 +nvme4n1 40589.00 5073.62 0.00 0.00 2.55 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 103.50 80.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38964.00 4870.50 0.00 0.00 2.21 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 86.19 77.60 +nvme2n1 38661.00 4832.62 0.00 0.00 4.10 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 158.41 86.10 +nvme3n1 38685.00 4835.62 0.00 0.00 2.13 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 82.35 77.70 +nvme4n1 38847.00 4855.88 0.00 0.00 3.11 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 120.64 77.70 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37804.00 4725.50 0.00 0.00 2.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 86.47 75.00 +nvme2n1 38002.00 4750.38 0.00 0.00 2.87 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 108.91 74.90 +nvme3n1 37863.00 4732.88 0.00 0.00 3.28 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.38 75.40 +nvme4n1 37867.00 4733.38 0.00 0.00 3.02 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 114.55 75.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37984.00 4748.00 0.00 0.00 2.53 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 96.28 75.80 +nvme2n1 37961.00 4745.00 0.00 0.00 3.81 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 144.71 76.30 +nvme3n1 38076.00 4759.50 0.00 0.00 3.02 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 115.02 76.80 +nvme4n1 38038.00 4754.75 0.00 0.00 2.04 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 77.65 76.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 41939.00 5242.38 0.00 0.00 2.41 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 100.98 82.40 +nvme2n1 41712.00 5214.00 0.00 0.00 3.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 138.01 90.60 +nvme3n1 41769.00 5221.12 0.00 0.00 2.52 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 105.37 82.40 +nvme4n1 41817.00 5227.12 0.00 0.00 2.99 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.03 82.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 36626.00 4578.25 0.00 0.00 2.08 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 76.09 90.90 +nvme2n1 37106.00 4638.25 0.00 0.00 3.57 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.51 83.20 +nvme3n1 37047.00 4630.88 0.00 0.00 3.55 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.65 75.30 +nvme4n1 36726.00 4590.75 0.00 0.00 2.41 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 88.36 75.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37664.00 4708.00 0.00 0.00 2.50 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 94.26 82.80 +nvme2n1 37550.00 4693.88 0.00 0.00 4.00 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 150.27 75.20 +nvme3n1 37550.00 4693.75 0.00 0.00 2.20 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 82.66 75.60 +nvme4n1 37717.00 4714.62 0.00 0.00 2.84 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 107.06 75.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 41403.00 5175.38 0.00 0.00 2.09 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 86.36 82.90 +nvme2n1 41392.00 5173.88 0.00 0.00 2.81 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 116.43 82.60 +nvme3n1 41394.00 5174.25 0.00 0.00 3.67 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 151.81 82.30 +nvme4n1 41372.00 5171.50 0.00 0.00 2.87 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 118.58 82.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37988.00 4748.50 0.00 0.00 2.26 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 85.81 75.70 +nvme2n1 38073.00 4759.12 0.00 0.00 4.53 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 172.33 76.60 +nvme3n1 38050.00 4756.25 0.00 0.00 2.37 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 90.31 76.40 +nvme4n1 38026.00 4753.25 0.00 0.00 2.69 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 102.11 76.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 5005.00 620.54 0.00 0.00 3.33 126.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 16.66 9.90 +nvme2n1 5048.00 625.91 0.00 0.00 2.86 126.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 14.43 9.90 +nvme3n1 5071.00 628.79 0.00 0.00 2.71 126.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 13.73 9.70 +nvme4n1 4967.00 615.79 0.00 0.00 2.05 126.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.20 9.70 + diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io14.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io14.txt new file mode 100644 index 0000000..1924980 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io14.txt @@ -0,0 +1,148 @@ +Linux 6.8.0-147-generic (node) 11/04/2026 _x86_64_ (96 CPU) + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 5485.96 677.53 38.93 0.70 23.06 126.47 5024.25 620.17 30.84 0.61 26.01 126.40 7.82 31989.95 0.00 0.00 244.43 4190769.01 0.00 0.00 259.14 24.72 +nvme2n1 4036.45 500.37 32.96 0.81 15.88 126.94 3849.15 476.04 26.46 0.68 19.04 126.64 7.82 31989.95 0.00 0.00 242.05 4190769.01 0.00 0.00 139.29 18.89 +nvme3n1 2802.71 347.93 11.92 0.42 12.51 127.12 2861.26 354.33 9.55 0.33 14.61 126.81 7.82 31989.95 0.00 0.00 243.15 4190769.01 0.00 0.00 78.76 14.29 +nvme4n1 2225.31 275.71 13.91 0.62 13.97 126.87 2282.72 282.03 10.78 0.47 13.67 126.52 7.82 31989.95 0.00 0.00 242.08 4190769.01 0.00 0.00 64.19 12.27 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 54.00 1.08 0.00 0.00 0.78 20.44 12567.00 1570.38 0.00 0.00 15.50 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 194.83 33.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 11857.00 1481.50 0.00 0.00 4.26 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 50.48 29.80 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 11650.00 1456.12 0.00 0.00 0.48 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 5.55 24.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 5793.00 724.00 0.00 0.00 0.15 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.85 13.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36133.00 4515.62 0.00 0.00 7.63 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 275.63 88.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36412.00 4550.25 0.00 0.00 4.63 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 168.58 85.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36578.00 4571.62 0.00 0.00 7.77 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 284.39 91.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18306.00 2288.00 0.00 0.00 0.17 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3.06 41.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36876.00 4608.00 0.00 0.00 8.40 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 309.78 91.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36860.00 4605.62 0.00 0.00 10.67 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 393.40 93.90 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36633.00 4578.38 0.00 0.00 0.97 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 35.62 83.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18318.00 2289.38 0.00 0.00 0.15 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.72 41.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37162.00 4644.25 0.00 0.00 5.90 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 219.16 90.70 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37052.00 4630.25 0.00 0.00 5.63 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 208.78 88.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36957.00 4619.12 0.00 0.00 9.15 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 338.00 94.70 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18455.00 2306.62 0.00 0.00 0.15 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.78 41.90 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37142.00 4641.88 0.00 0.00 5.85 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 217.30 89.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37670.00 4707.50 0.00 0.00 8.92 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 335.92 93.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37327.00 4665.38 0.00 0.00 4.93 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 183.96 88.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18594.00 2324.00 0.00 0.00 0.15 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.76 39.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36337.00 4541.00 0.00 0.00 8.89 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 323.20 92.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36113.00 4512.88 0.00 0.00 6.37 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 229.88 89.60 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36750.00 4593.38 0.00 0.00 5.27 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 193.80 90.60 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18466.00 2308.00 0.00 0.00 0.15 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.71 41.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36433.00 4552.62 0.00 0.00 5.91 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 215.48 87.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36372.00 4544.62 0.00 0.00 6.78 127.95 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 246.75 87.30 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36090.00 4510.38 0.00 0.00 6.26 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 226.05 87.50 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18045.00 2255.25 0.00 0.00 0.15 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.77 41.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37209.00 4650.25 0.00 0.00 8.98 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 334.12 95.30 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37073.00 4632.88 0.00 0.00 8.03 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 297.82 94.60 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37292.00 4661.12 0.00 0.00 3.23 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 120.42 90.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 18632.00 2328.75 0.00 0.00 0.14 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.69 41.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 10192.00 1273.88 0.00 0.00 9.86 127.99 8737.00 1092.00 0.00 0.00 7.07 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 162.32 98.90 +nvme2n1 9973.00 1246.25 0.00 0.00 2.47 127.96 9204.00 1150.50 0.00 0.00 12.25 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 137.34 44.60 +nvme3n1 9797.00 1224.50 0.00 0.00 1.50 127.99 9285.00 1160.50 0.00 0.00 0.50 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 19.35 40.70 +nvme4n1 4857.00 607.12 0.00 0.00 0.59 128.00 4672.00 584.00 0.00 0.00 0.14 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3.54 28.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38963.00 4870.12 0.00 0.00 5.20 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 202.63 79.60 +nvme2n1 39188.00 4897.75 0.00 0.00 5.21 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 204.03 79.70 +nvme3n1 39265.00 4907.88 0.00 0.00 3.93 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 154.23 81.10 +nvme4n1 19613.00 2451.62 0.00 0.00 0.60 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.82 67.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 35841.00 4479.75 0.00 0.00 5.42 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 194.42 90.30 +nvme2n1 35401.00 4424.00 0.00 0.00 7.39 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 261.49 72.40 +nvme3n1 35351.00 4418.50 0.00 0.00 1.61 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 57.01 72.40 +nvme4n1 17706.00 2213.25 0.00 0.00 0.59 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10.47 62.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 41030.00 5128.50 0.00 0.00 5.52 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 226.62 81.10 +nvme2n1 40911.00 5113.12 0.00 0.00 5.45 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 223.13 80.80 +nvme3n1 40823.00 5102.62 0.00 0.00 2.93 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 119.78 81.60 +nvme4n1 20384.00 2548.12 0.00 0.00 0.60 128.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.31 67.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37824.00 4727.75 0.00 0.00 3.23 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 122.07 86.10 +nvme2n1 38397.00 4798.88 0.00 0.00 7.36 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 282.44 78.30 +nvme3n1 38614.00 4826.50 0.00 0.00 3.67 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 141.64 79.60 +nvme4n1 19360.00 2419.88 0.00 0.00 0.60 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.62 65.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37350.00 4668.38 0.00 0.00 4.50 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 168.00 74.50 +nvme2n1 36893.00 4610.50 0.00 0.00 7.60 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 280.54 74.60 +nvme3n1 36542.00 4567.38 0.00 0.00 1.97 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 71.88 74.10 +nvme4n1 18212.00 2276.50 0.00 0.00 0.61 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.04 62.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39985.00 4997.88 0.00 0.00 4.13 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 165.01 80.50 +nvme2n1 40024.00 5002.25 0.00 0.00 6.18 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 247.48 80.20 +nvme3n1 40174.00 5021.50 0.00 0.00 3.79 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 152.44 81.60 +nvme4n1 20092.00 2511.50 0.00 0.00 0.62 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12.50 65.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37360.00 4669.75 0.00 0.00 3.70 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 138.26 83.30 +nvme2n1 37792.00 4723.25 0.00 0.00 8.03 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 303.52 75.50 +nvme3n1 37979.00 4747.12 0.00 0.00 2.19 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 83.01 76.10 +nvme4n1 19040.00 2380.00 0.00 0.00 0.62 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11.72 62.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.30 +nvme2n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.30 +nvme3n1 49.00 1.04 0.00 0.00 0.08 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.20 +nvme4n1 49.00 1.04 0.00 0.00 0.06 21.63 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.30 + diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io16.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io16.txt new file mode 100644 index 0000000..0b99e42 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/io16.txt @@ -0,0 +1,155 @@ +Linux 6.8.0-147-generic (node) 11/04/2026 _x86_64_ (96 CPU) + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 5530.15 683.19 38.24 0.69 22.60 126.50 5076.46 626.83 30.29 0.59 25.51 126.44 8.13 33275.77 0.00 0.00 244.43 4190769.01 0.00 0.00 256.44 25.08 +nvme2n1 4106.13 509.14 32.38 0.78 15.56 126.97 3922.05 485.24 25.99 0.66 18.62 126.69 8.13 33275.77 0.00 0.00 242.71 4190769.01 0.00 0.00 138.91 19.30 +nvme3n1 2894.08 359.39 11.71 0.40 12.04 127.16 2951.51 365.67 9.38 0.32 14.15 126.87 8.13 33275.77 0.00 0.00 243.39 4190769.01 0.00 0.00 78.59 14.77 +nvme4n1 2256.55 279.65 13.66 0.60 13.55 126.90 2312.85 285.85 10.59 0.46 13.26 126.56 8.13 33275.77 0.00 0.00 242.85 4190769.01 0.00 0.00 63.23 12.56 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 52.00 1.05 0.00 0.00 0.33 20.62 9922.00 1240.00 0.00 0.00 14.06 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 139.56 25.40 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 9891.00 1236.00 0.00 0.00 1.43 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 14.12 22.20 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 9139.00 1142.00 0.00 0.00 4.66 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 42.55 22.90 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 8964.00 1120.00 0.00 0.00 0.31 127.94 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2.79 19.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36356.00 4544.12 0.00 0.00 4.87 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 176.91 92.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35918.00 4489.00 0.00 0.00 6.13 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 220.03 87.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36565.00 4570.00 0.00 0.00 5.89 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 215.44 90.10 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36595.00 4573.38 0.00 0.00 3.72 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.24 90.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36125.00 4514.78 0.00 0.00 3.47 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.50 85.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36384.00 4547.00 0.00 0.00 7.72 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 280.96 87.60 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36448.00 4554.88 0.00 0.00 5.77 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 210.15 85.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36549.00 4567.25 0.00 0.00 2.74 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 100.27 86.60 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36538.00 4566.72 0.00 0.00 3.89 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 142.31 88.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36096.00 4511.12 0.00 0.00 7.52 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 271.56 87.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36030.00 4502.88 0.00 0.00 4.25 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 153.14 87.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 35983.00 4496.75 0.00 0.00 5.21 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 187.65 89.40 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 37010.00 4625.75 0.00 0.00 3.04 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 112.58 87.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 37630.00 4703.00 0.00 0.00 5.61 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 210.98 88.70 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 37237.00 4653.88 0.00 0.00 7.57 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 281.89 92.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 37088.00 4635.00 0.00 0.00 3.40 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 126.11 89.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36212.00 4526.00 0.00 0.00 4.26 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 154.34 91.20 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36025.00 4502.38 0.00 0.00 8.97 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 323.22 91.40 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36473.00 4558.38 0.00 0.00 1.45 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 53.06 85.30 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36230.00 4527.88 0.00 0.00 5.99 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 217.11 91.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36698.00 4586.75 0.00 0.00 1.84 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 67.47 84.10 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 36886.00 4610.00 0.00 0.00 5.97 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 220.07 88.10 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 36900.00 4611.75 0.00 0.00 8.05 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 297.17 90.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36771.00 4595.25 0.00 0.00 3.57 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.41 87.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 36218.00 4526.50 0.00 0.00 3.94 127.98 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 142.71 87.90 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 35582.00 4446.75 0.00 0.00 10.92 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 388.70 91.50 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 35425.00 4427.00 0.00 0.00 1.40 127.97 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 49.43 81.80 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 36006.00 4499.25 0.00 0.00 4.28 127.96 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 154.08 89.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 1913.00 239.12 0.00 0.00 6.30 128.00 13483.00 1685.38 0.00 0.00 0.36 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 16.95 33.40 +nvme2n1 1502.00 187.62 0.00 0.00 4.69 127.91 14167.00 1770.75 0.00 0.00 5.51 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 85.14 35.10 +nvme3n1 1362.00 170.25 0.00 0.00 1.44 128.00 14362.00 1795.25 0.00 0.00 12.22 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 177.51 39.90 +nvme4n1 1217.00 152.12 0.00 0.00 1.33 128.00 14410.00 1801.25 0.00 0.00 0.55 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 9.61 35.10 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39533.00 4941.62 0.00 0.00 4.61 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 182.11 88.80 +nvme2n1 39487.00 4935.62 0.00 0.00 4.38 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 172.85 78.00 +nvme3n1 39363.00 4920.38 0.00 0.00 3.08 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 121.36 78.90 +nvme4n1 39357.00 4919.62 0.00 0.00 2.05 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 80.63 80.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39298.00 4912.38 0.00 0.00 2.55 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 100.23 88.70 +nvme2n1 39632.00 4953.88 0.00 0.00 6.77 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 268.32 78.70 +nvme3n1 39400.00 4925.12 0.00 0.00 3.49 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 137.45 79.10 +nvme4n1 39332.00 4916.50 0.00 0.00 1.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 66.27 79.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 33944.00 4242.88 0.00 0.00 2.82 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 95.69 68.20 +nvme2n1 34074.00 4258.88 0.00 0.00 6.89 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 234.65 67.80 +nvme3n1 34563.00 4320.25 0.00 0.00 3.03 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 104.83 69.10 +nvme4n1 34782.00 4347.75 0.00 0.00 2.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 80.05 71.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38458.00 4807.25 0.00 0.00 3.07 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 118.16 88.00 +nvme2n1 38101.00 4762.25 0.00 0.00 6.58 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 250.78 76.50 +nvme3n1 37879.00 4734.88 0.00 0.00 3.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 139.25 77.60 +nvme4n1 37747.00 4718.38 0.00 0.00 1.65 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 62.24 77.30 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 38712.00 4839.00 0.00 0.00 2.71 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 104.73 88.60 +nvme2n1 38592.00 4823.75 0.00 0.00 6.90 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 266.16 77.50 +nvme3n1 38612.00 4826.50 0.00 0.00 2.68 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 103.49 78.20 +nvme4n1 38559.00 4819.88 0.00 0.00 2.66 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 102.63 79.80 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 37518.00 4689.75 0.00 0.00 3.04 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 114.00 87.60 +nvme2n1 38002.00 4750.00 0.00 0.00 4.80 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 182.26 77.10 +nvme3n1 38197.00 4774.62 0.00 0.00 4.81 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 183.74 79.00 +nvme4n1 37829.00 4728.62 0.00 0.00 2.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 87.18 78.50 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 34196.00 4274.50 0.00 0.00 3.26 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 111.63 89.40 +nvme2n1 33765.00 4220.25 0.00 0.00 7.48 127.99 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 252.67 67.60 +nvme3n1 33604.00 4200.50 0.00 0.00 1.91 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 64.30 67.30 +nvme4n1 34013.00 4251.62 0.00 0.00 2.01 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 68.32 69.00 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 15005.00 1870.54 0.00 0.00 1.72 127.65 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 25.75 30.60 +nvme2n1 15439.00 1924.79 0.00 0.00 5.60 127.66 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 86.44 30.90 +nvme3n1 15597.00 1944.54 0.00 0.00 5.48 127.67 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 85.40 32.00 +nvme4n1 15741.00 1962.54 0.00 0.00 1.50 127.67 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 23.66 32.20 + + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme2n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme3n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 +nvme4n1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 + diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/main_upgrade/results.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/main_upgrade/results.jsonl new file mode 100644 index 0000000..c8e9be1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/main_upgrade/results.jsonl @@ -0,0 +1,14 @@ +{"step": "clean_main_stores", "mode": "store", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "clean_fixed_reads_main", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "clean_fixed_stores", "mode": "store", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} +{"step": "clean_fixed_reads_fixed", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} +{"step": "clean_fixed_reads_main_again", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "clean_rollback_reads_main", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "clean_rollback_reads_fixed", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} +{"step": "kill_main_stores", "mode": "store", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "kill_fixed_reads_main", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "kill_fixed_stores", "mode": "store", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} +{"step": "kill_fixed_reads_fixed", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} +{"step": "kill_fixed_reads_main_again", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "kill_rollback_reads_main", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme1n1": 300}} +{"step": "kill_rollback_reads_fixed", "mode": "check", "objects": 300, "right": 300, "miss": 0, "wrong": 0, "first_chunk": {"/dev/nvme4n1": 72, "/dev/nvme2n1": 72, "/dev/nvme1n1": 78, "/dev/nvme3n1": 78}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-1.json new file mode 100644 index 0000000..629b5bf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-1.json @@ -0,0 +1 @@ +{"ok": 8192, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 6.13, "mb_s": 19628, "batch_ms_p50": 46.1, "batch_ms_p99": 65.7, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 120259084288, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-2.json new file mode 100644 index 0000000..6b1cc08 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-2.json @@ -0,0 +1 @@ +{"ok": 8192, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 6.16, "mb_s": 19528, "batch_ms_p50": 46.1, "batch_ms_p99": 64.3, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 120259084288, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-3.json new file mode 100644 index 0000000..853e064 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/fill-3.json @@ -0,0 +1 @@ +{"ok": 8192, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 6.09, "mb_s": 19737, "batch_ms_p50": 45.9, "batch_ms_p99": 57.9, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 120259084288, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-1.json new file mode 100644 index 0000000..107f133 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-1.json @@ -0,0 +1 @@ +{"ok": 51096, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.51, "mb_s": 25420, "batch_ms_p50": 36.9, "batch_ms_p99": 43.5, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 750092550144, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-2.json new file mode 100644 index 0000000..898ef46 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-2.json @@ -0,0 +1 @@ +{"ok": 50712, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.5, "mb_s": 25235, "batch_ms_p50": 37.1, "batch_ms_p99": 44.2, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 744455405568, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-3.json new file mode 100644 index 0000000..94766b5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/load_alone-3.json @@ -0,0 +1 @@ +{"ok": 51128, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.51, "mb_s": 25434, "batch_ms_p50": 36.8, "batch_ms_p99": 43.3, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 750562312192, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-1.json new file mode 100644 index 0000000..77b494d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-1.json @@ -0,0 +1 @@ +{"ok": 13040, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.55, "mb_s": 6478, "batch_ms_p50": 144.6, "batch_ms_p99": 187.4, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 191428034560, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-2.json new file mode 100644 index 0000000..10585a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-2.json @@ -0,0 +1 @@ +{"ok": 12704, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.5, "mb_s": 6321, "batch_ms_p50": 148.7, "batch_ms_p99": 189.8, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 186495533056, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-3.json new file mode 100644 index 0000000..a01657f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate0-3.json @@ -0,0 +1 @@ +{"ok": 13192, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.54, "mb_s": 6556, "batch_ms_p50": 143.2, "batch_ms_p99": 182.6, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 193659404288, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-1.json new file mode 100644 index 0000000..1698048 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-1.json @@ -0,0 +1 @@ +{"ok": 48584, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.49, "mb_s": 24181, "batch_ms_p50": 37.8, "batch_ms_p99": 50.2, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 713216229376, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-2.json new file mode 100644 index 0000000..510b9cd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-2.json @@ -0,0 +1 @@ +{"ok": 48320, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.49, "mb_s": 24051, "batch_ms_p50": 38.1, "batch_ms_p99": 50.2, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 709340692480, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-3.json new file mode 100644 index 0000000..682e4f3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate1000-3.json @@ -0,0 +1 @@ +{"ok": 48632, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.5, "mb_s": 24199, "batch_ms_p50": 37.8, "batch_ms_p99": 49.8, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 713920872448, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-1.json new file mode 100644 index 0000000..ef66424 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-1.json @@ -0,0 +1 @@ +{"ok": 38376, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.5, "mb_s": 19099, "batch_ms_p50": 49.5, "batch_ms_p99": 60.4, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 563362136064, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-2.json new file mode 100644 index 0000000..97ca34c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-2.json @@ -0,0 +1 @@ +{"ok": 38360, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.51, "mb_s": 19081, "batch_ms_p50": 49.5, "batch_ms_p99": 59.9, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 563127255040, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-3.json new file mode 100644 index 0000000..6fc8774 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/r_rate4000-3.json @@ -0,0 +1 @@ +{"ok": 38600, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.49, "mb_s": 19212, "batch_ms_p50": 49.2, "batch_ms_p99": 59.4, "wrong_ids": [], "errors": {}, "mode": "load", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 566650470400, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-1.json new file mode 100644 index 0000000..4eb02ff --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-1.json @@ -0,0 +1 @@ +{"ok": 39488, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.52, "mb_s": 19640, "batch_ms_p50": 46.0, "batch_ms_p99": 58.2, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 579686367232, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-2.json new file mode 100644 index 0000000..a186e36 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-2.json @@ -0,0 +1 @@ +{"ok": 40304, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.51, "mb_s": 20048, "batch_ms_p50": 45.5, "batch_ms_p99": 56.1, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 591665299456, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-3.json new file mode 100644 index 0000000..871571e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/store_alone-3.json @@ -0,0 +1 @@ +{"ok": 40360, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.51, "mb_s": 20075, "batch_ms_p50": 45.4, "batch_ms_p99": 55.1, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 592487383040, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-1.json new file mode 100644 index 0000000..4ccb56b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-1.json @@ -0,0 +1 @@ +{"ok": 24464, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.53, "mb_s": 12163, "batch_ms_p50": 74.7, "batch_ms_p99": 121.2, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 359133085696, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-2.json new file mode 100644 index 0000000..aac4942 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-2.json @@ -0,0 +1 @@ +{"ok": 24616, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.5, "mb_s": 12249, "batch_ms_p50": 74.5, "batch_ms_p99": 115.9, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 361364455424, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-3.json new file mode 100644 index 0000000..f888084 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate0-3.json @@ -0,0 +1 @@ +{"ok": 24248, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.52, "mb_s": 12058, "batch_ms_p50": 75.6, "batch_ms_p99": 120.2, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 355962191872, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-1.json new file mode 100644 index 0000000..a3040d6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-1.json @@ -0,0 +1 @@ +{"ok": 2008, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 1000, "batch_ms_p50": 14.5, "batch_ms_p99": 17.3, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 29477568512, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-2.json new file mode 100644 index 0000000..7756f3b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-2.json @@ -0,0 +1 @@ +{"ok": 2008, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 1000, "batch_ms_p50": 14.5, "batch_ms_p99": 17.2, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 29477568512, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-3.json new file mode 100644 index 0000000..a3040d6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate1000-3.json @@ -0,0 +1 @@ +{"ok": 2008, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 1000, "batch_ms_p50": 14.5, "batch_ms_p99": 17.3, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 29477568512, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-1.json new file mode 100644 index 0000000..d4c3acf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-1.json @@ -0,0 +1 @@ +{"ok": 8032, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 4001, "batch_ms_p50": 14.0, "batch_ms_p99": 17.3, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 117910274048, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-2.json new file mode 100644 index 0000000..da71546 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-2.json @@ -0,0 +1 @@ +{"ok": 8032, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 4000, "batch_ms_p50": 14.1, "batch_ms_p99": 17.5, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 117910274048, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-3.json new file mode 100644 index 0000000..99270d3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/mixed/w_rate4000-3.json @@ -0,0 +1 @@ +{"ok": 8032, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 29.47, "mb_s": 4001, "batch_ms_p50": 14.1, "batch_ms_p99": 17.6, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 117910274048, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.cpu new file mode 100644 index 0000000..88a2f67 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.095481157302856, "user_s": 86.752675, "sys_s": 22.048565, "max_rss_kb": 4052712} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.json new file mode 100644 index 0000000..76a1cde --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 360.3, + "duration_min_ms": 330.1, + "duration_max_ms": 382.07, + "duration_p50_ms": 366.9, + "duration_p99_ms": 382.07, + "duration_std_ms": 16.15, + "throughput_avg_mbps": 4983.67, + "throughput_min_mbps": 4690.21, + "throughput_max_mbps": 5428.7, + "ops_per_sec_avg": 355.98, + "latency_per_key_ms": 2.815 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.96, + "duration_min_ms": 0.76, + "duration_max_ms": 1.07, + "duration_p50_ms": 1.0, + "duration_p99_ms": 1.07, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 135470.52, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 304.43, + "duration_min_ms": 297.04, + "duration_max_ms": 313.43, + "duration_p50_ms": 303.98, + "duration_p99_ms": 313.43, + "duration_std_ms": 3.7, + "throughput_avg_mbps": 5887.25, + "throughput_min_mbps": 5717.33, + "throughput_max_mbps": 6032.77, + "ops_per_sec_avg": 420.52, + "latency_per_key_ms": 2.378 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.cpu new file mode 100644 index 0000000..4486866 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.55652952194214, "user_s": 85.62371, "sys_s": 23.158924, "max_rss_kb": 4052312} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.json new file mode 100644 index 0000000..47e7875 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 366.98, + "duration_min_ms": 326.17, + "duration_max_ms": 485.7, + "duration_p50_ms": 362.12, + "duration_p99_ms": 485.7, + "duration_std_ms": 29.88, + "throughput_avg_mbps": 4912.67, + "throughput_min_mbps": 3689.51, + "throughput_max_mbps": 5494.14, + "ops_per_sec_avg": 350.91, + "latency_per_key_ms": 2.867 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 1.0, + "duration_min_ms": 0.78, + "duration_max_ms": 1.05, + "duration_p50_ms": 1.01, + "duration_p99_ms": 1.05, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 128942.28, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 307.04, + "duration_min_ms": 299.56, + "duration_max_ms": 314.26, + "duration_p50_ms": 307.04, + "duration_p99_ms": 314.26, + "duration_std_ms": 3.45, + "throughput_avg_mbps": 5837.06, + "throughput_min_mbps": 5702.36, + "throughput_max_mbps": 5982.11, + "ops_per_sec_avg": 416.93, + "latency_per_key_ms": 2.399 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.cpu new file mode 100644 index 0000000..8f61860 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.44877052307129, "user_s": 86.194981, "sys_s": 23.244209, "max_rss_kb": 4053092} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.json new file mode 100644 index 0000000..694dc36 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 366.99, + "duration_min_ms": 329.51, + "duration_max_ms": 453.11, + "duration_p50_ms": 364.88, + "duration_p99_ms": 453.11, + "duration_std_ms": 25.86, + "throughput_avg_mbps": 4905.92, + "throughput_min_mbps": 3954.92, + "throughput_max_mbps": 5438.42, + "ops_per_sec_avg": 350.42, + "latency_per_key_ms": 2.867 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.94, + "duration_min_ms": 0.76, + "duration_max_ms": 1.03, + "duration_p50_ms": 0.99, + "duration_p99_ms": 1.03, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 137116.07, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 304.89, + "duration_min_ms": 296.9, + "duration_max_ms": 313.5, + "duration_p50_ms": 304.92, + "duration_p99_ms": 313.5, + "duration_std_ms": 3.43, + "throughput_avg_mbps": 5878.34, + "throughput_min_mbps": 5716.05, + "throughput_max_mbps": 6035.78, + "ops_per_sec_avg": 419.88, + "latency_per_key_ms": 2.382 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.cpu new file mode 100644 index 0000000..cef57a5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.24265217781067, "user_s": 87.191194, "sys_s": 22.694867, "max_rss_kb": 4052376} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.json new file mode 100644 index 0000000..f18faf6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 360.3, + "duration_min_ms": 330.22, + "duration_max_ms": 382.81, + "duration_p50_ms": 365.31, + "duration_p99_ms": 382.81, + "duration_std_ms": 16.31, + "throughput_avg_mbps": 4983.89, + "throughput_min_mbps": 4681.11, + "throughput_max_mbps": 5426.65, + "ops_per_sec_avg": 355.99, + "latency_per_key_ms": 2.815 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.83, + "duration_min_ms": 0.67, + "duration_max_ms": 0.92, + "duration_p50_ms": 0.9, + "duration_p99_ms": 0.92, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 156791.05, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 290.5, + "duration_min_ms": 285.63, + "duration_max_ms": 296.53, + "duration_p50_ms": 290.11, + "duration_p99_ms": 296.53, + "duration_std_ms": 2.51, + "throughput_avg_mbps": 6169.11, + "throughput_min_mbps": 6043.15, + "throughput_max_mbps": 6273.83, + "ops_per_sec_avg": 440.65, + "latency_per_key_ms": 2.27 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.cpu new file mode 100644 index 0000000..80064d8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.17352557182312, "user_s": 87.691004, "sys_s": 21.542832, "max_rss_kb": 4053416} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.json new file mode 100644 index 0000000..7c358f9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 358.86, + "duration_min_ms": 323.35, + "duration_max_ms": 408.23, + "duration_p50_ms": 362.27, + "duration_p99_ms": 408.23, + "duration_std_ms": 17.8, + "throughput_avg_mbps": 5005.74, + "throughput_min_mbps": 4389.7, + "throughput_max_mbps": 5542.01, + "ops_per_sec_avg": 357.55, + "latency_per_key_ms": 2.804 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.86, + "duration_min_ms": 0.67, + "duration_max_ms": 0.92, + "duration_p50_ms": 0.9, + "duration_p99_ms": 0.92, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 150429.55, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 291.53, + "duration_min_ms": 285.8, + "duration_max_ms": 297.6, + "duration_p50_ms": 291.08, + "duration_p99_ms": 297.6, + "duration_std_ms": 2.47, + "throughput_avg_mbps": 6147.3, + "throughput_min_mbps": 6021.54, + "throughput_max_mbps": 6270.02, + "ops_per_sec_avg": 439.09, + "latency_per_key_ms": 2.278 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.cpu new file mode 100644 index 0000000..ef0ac62 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.56833505630493, "user_s": 85.610545, "sys_s": 23.149971, "max_rss_kb": 4048880} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.json new file mode 100644 index 0000000..c95e651 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_posix_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 365.62, + "duration_min_ms": 322.33, + "duration_max_ms": 468.3, + "duration_p50_ms": 360.78, + "duration_p99_ms": 468.3, + "duration_std_ms": 27.99, + "throughput_avg_mbps": 4928.13, + "throughput_min_mbps": 3826.62, + "throughput_max_mbps": 5559.51, + "ops_per_sec_avg": 352.01, + "latency_per_key_ms": 2.856 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.91, + "duration_min_ms": 0.71, + "duration_max_ms": 0.97, + "duration_p50_ms": 0.95, + "duration_p99_ms": 0.97, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 142812.58, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 290.78, + "duration_min_ms": 287.01, + "duration_max_ms": 297.51, + "duration_p50_ms": 290.44, + "duration_p99_ms": 297.51, + "duration_std_ms": 2.32, + "throughput_avg_mbps": 6163.05, + "throughput_min_mbps": 6023.24, + "throughput_max_mbps": 6243.65, + "ops_per_sec_avg": 440.22, + "latency_per_key_ms": 2.272 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.cpu new file mode 100644 index 0000000..6f43d13 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.247684717178345, "user_s": 117.50982, "sys_s": 59.078539, "max_rss_kb": 4056568} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.json new file mode 100644 index 0000000..4ce07ea --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 360.36, + "duration_min_ms": 327.72, + "duration_max_ms": 398.91, + "duration_p50_ms": 365.9, + "duration_p99_ms": 398.91, + "duration_std_ms": 17.75, + "throughput_avg_mbps": 4984.8, + "throughput_min_mbps": 4492.26, + "throughput_max_mbps": 5468.1, + "ops_per_sec_avg": 356.06, + "latency_per_key_ms": 2.815 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.92, + "duration_min_ms": 0.74, + "duration_max_ms": 1.0, + "duration_p50_ms": 0.97, + "duration_p99_ms": 1.0, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 140109.95, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 307.75, + "duration_min_ms": 292.83, + "duration_max_ms": 343.72, + "duration_p50_ms": 304.71, + "duration_p99_ms": 343.72, + "duration_std_ms": 11.28, + "throughput_avg_mbps": 5830.26, + "throughput_min_mbps": 5213.58, + "throughput_max_mbps": 6119.56, + "ops_per_sec_avg": 416.45, + "latency_per_key_ms": 2.404 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.cpu new file mode 100644 index 0000000..4f54089 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.182400941848755, "user_s": 118.848682, "sys_s": 57.136098, "max_rss_kb": 4052048} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.json new file mode 100644 index 0000000..b6a92ed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 364.34, + "duration_min_ms": 324.1, + "duration_max_ms": 456.04, + "duration_p50_ms": 360.5, + "duration_p99_ms": 456.04, + "duration_std_ms": 26.15, + "throughput_avg_mbps": 4942.32, + "throughput_min_mbps": 3929.45, + "throughput_max_mbps": 5529.2, + "ops_per_sec_avg": 353.02, + "latency_per_key_ms": 2.846 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.95, + "duration_min_ms": 0.75, + "duration_max_ms": 1.0, + "duration_p50_ms": 0.98, + "duration_p99_ms": 1.0, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 136534.78, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 303.29, + "duration_min_ms": 291.19, + "duration_max_ms": 338.94, + "duration_p50_ms": 299.66, + "duration_p99_ms": 338.94, + "duration_std_ms": 10.45, + "throughput_avg_mbps": 5915.17, + "throughput_min_mbps": 5287.0, + "throughput_max_mbps": 6154.16, + "ops_per_sec_avg": 422.51, + "latency_per_key_ms": 2.369 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.cpu new file mode 100644 index 0000000..e19ca2b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 45.00295352935791, "user_s": 118.826148, "sys_s": 54.211587, "max_rss_kb": 4054624} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.json new file mode 100644 index 0000000..312a36a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 366.61, + "duration_min_ms": 326.12, + "duration_max_ms": 463.12, + "duration_p50_ms": 363.93, + "duration_p99_ms": 463.12, + "duration_std_ms": 28.06, + "throughput_avg_mbps": 4915.18, + "throughput_min_mbps": 3869.44, + "throughput_max_mbps": 5494.9, + "ops_per_sec_avg": 351.08, + "latency_per_key_ms": 2.864 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.9, + "duration_min_ms": 0.72, + "duration_max_ms": 0.98, + "duration_p50_ms": 0.96, + "duration_p99_ms": 0.98, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 143624.7, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 314.26, + "duration_min_ms": 292.01, + "duration_max_ms": 346.89, + "duration_p50_ms": 312.73, + "duration_p99_ms": 346.89, + "duration_std_ms": 14.3, + "throughput_avg_mbps": 5713.64, + "throughput_min_mbps": 5165.85, + "throughput_max_mbps": 6136.87, + "ops_per_sec_avg": 408.12, + "latency_per_key_ms": 2.455 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.cpu new file mode 100644 index 0000000..5e62b08 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.732847929000854, "user_s": 102.766859, "sys_s": 47.765522, "max_rss_kb": 4052724} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.json new file mode 100644 index 0000000..6c91052 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 360.83, + "duration_min_ms": 326.5, + "duration_max_ms": 414.91, + "duration_p50_ms": 365.57, + "duration_p99_ms": 414.91, + "duration_std_ms": 18.75, + "throughput_avg_mbps": 4979.58, + "throughput_min_mbps": 4319.06, + "throughput_max_mbps": 5488.49, + "ops_per_sec_avg": 355.68, + "latency_per_key_ms": 2.819 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.87, + "duration_min_ms": 0.7, + "duration_max_ms": 0.97, + "duration_p50_ms": 0.95, + "duration_p99_ms": 0.97, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 148740.11, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 299.9, + "duration_min_ms": 288.1, + "duration_max_ms": 327.35, + "duration_p50_ms": 298.43, + "duration_p99_ms": 327.35, + "duration_std_ms": 8.49, + "throughput_avg_mbps": 5979.9, + "throughput_min_mbps": 5474.33, + "throughput_max_mbps": 6219.97, + "ops_per_sec_avg": 427.14, + "latency_per_key_ms": 2.343 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.cpu new file mode 100644 index 0000000..db4d0d9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.85294485092163, "user_s": 100.624373, "sys_s": 46.817572, "max_rss_kb": 4052980} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.json new file mode 100644 index 0000000..32d31d8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 361.75, + "duration_min_ms": 325.16, + "duration_max_ms": 402.73, + "duration_p50_ms": 366.31, + "duration_p99_ms": 402.73, + "duration_std_ms": 19.47, + "throughput_avg_mbps": 4967.9, + "throughput_min_mbps": 4449.6, + "throughput_max_mbps": 5511.08, + "ops_per_sec_avg": 354.85, + "latency_per_key_ms": 2.826 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.93, + "duration_min_ms": 0.72, + "duration_max_ms": 0.98, + "duration_p50_ms": 0.95, + "duration_p99_ms": 0.98, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 138586.44, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 299.97, + "duration_min_ms": 287.76, + "duration_max_ms": 318.48, + "duration_p50_ms": 299.09, + "duration_p99_ms": 318.48, + "duration_std_ms": 6.29, + "throughput_avg_mbps": 5976.45, + "throughput_min_mbps": 5626.67, + "throughput_max_mbps": 6227.45, + "ops_per_sec_avg": 426.89, + "latency_per_key_ms": 2.344 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.cpu new file mode 100644 index 0000000..26e3f22 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.49063849449158, "user_s": 104.042307, "sys_s": 46.258488, "max_rss_kb": 4055036} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.json new file mode 100644 index 0000000..3695a0d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/raw_uring_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 365.29, + "duration_min_ms": 329.96, + "duration_max_ms": 444.62, + "duration_p50_ms": 363.65, + "duration_p99_ms": 444.62, + "duration_std_ms": 25.23, + "throughput_avg_mbps": 4928.09, + "throughput_min_mbps": 4030.37, + "throughput_max_mbps": 5430.97, + "ops_per_sec_avg": 352.01, + "latency_per_key_ms": 2.854 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 0.9, + "duration_min_ms": 0.72, + "duration_max_ms": 0.97, + "duration_p50_ms": 0.95, + "duration_p99_ms": 0.97, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 143537.89, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 307.57, + "duration_min_ms": 288.13, + "duration_max_ms": 326.38, + "duration_p50_ms": 306.52, + "duration_p99_ms": 326.38, + "duration_std_ms": 9.05, + "throughput_avg_mbps": 5831.2, + "throughput_min_mbps": 5490.52, + "throughput_max_mbps": 6219.44, + "ops_per_sec_avg": 416.51, + "latency_per_key_ms": 2.403 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.cpu new file mode 100644 index 0000000..59abfd1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.48512601852417, "user_s": 97.555704, "sys_s": 28.02335, "max_rss_kb": 4043892} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.json new file mode 100644 index 0000000..3e10c58 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 358.95, + "duration_min_ms": 320.37, + "duration_max_ms": 390.72, + "duration_p50_ms": 362.21, + "duration_p99_ms": 390.72, + "duration_std_ms": 18.07, + "throughput_avg_mbps": 5005.09, + "throughput_min_mbps": 4586.38, + "throughput_max_mbps": 5593.52, + "ops_per_sec_avg": 357.51, + "latency_per_key_ms": 2.804 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 2.67, + "duration_min_ms": 2.52, + "duration_max_ms": 2.85, + "duration_p50_ms": 2.68, + "duration_p99_ms": 2.85, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48042.67, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 302.9, + "duration_min_ms": 297.09, + "duration_max_ms": 314.15, + "duration_p50_ms": 301.33, + "duration_p99_ms": 314.15, + "duration_std_ms": 3.9, + "throughput_avg_mbps": 5917.01, + "throughput_min_mbps": 5704.33, + "throughput_max_mbps": 6031.88, + "ops_per_sec_avg": 422.64, + "latency_per_key_ms": 2.366 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.cpu new file mode 100644 index 0000000..9bbd7f0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.770400524139404, "user_s": 97.471201, "sys_s": 27.149742, "max_rss_kb": 4047360} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.json new file mode 100644 index 0000000..4723e72 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 363.17, + "duration_min_ms": 321.83, + "duration_max_ms": 417.08, + "duration_p50_ms": 358.97, + "duration_p99_ms": 417.08, + "duration_std_ms": 24.96, + "throughput_avg_mbps": 4956.94, + "throughput_min_mbps": 4296.53, + "throughput_max_mbps": 5568.21, + "ops_per_sec_avg": 354.07, + "latency_per_key_ms": 2.837 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 2.54, + "duration_min_ms": 2.46, + "duration_max_ms": 2.75, + "duration_p50_ms": 2.53, + "duration_p99_ms": 2.75, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 50389.85, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 304.36, + "duration_min_ms": 297.89, + "duration_max_ms": 312.99, + "duration_p50_ms": 304.76, + "duration_p99_ms": 312.99, + "duration_std_ms": 3.33, + "throughput_avg_mbps": 5888.51, + "throughput_min_mbps": 5725.39, + "throughput_max_mbps": 6015.59, + "ops_per_sec_avg": 420.61, + "latency_per_key_ms": 2.378 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.cpu new file mode 100644 index 0000000..0da4aed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 44.699665546417236, "user_s": 96.057383, "sys_s": 27.552782, "max_rss_kb": 4043868} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.json new file mode 100644 index 0000000..e8835ad --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 364.24, + "duration_min_ms": 321.18, + "duration_max_ms": 408.14, + "duration_p50_ms": 362.11, + "duration_p99_ms": 408.14, + "duration_std_ms": 23.9, + "throughput_avg_mbps": 4940.53, + "throughput_min_mbps": 4390.65, + "throughput_max_mbps": 5579.48, + "ops_per_sec_avg": 352.9, + "latency_per_key_ms": 2.846 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 2.63, + "duration_min_ms": 2.51, + "duration_max_ms": 3.3, + "duration_p50_ms": 2.62, + "duration_p99_ms": 3.3, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48707.52, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 302.78, + "duration_min_ms": 294.7, + "duration_max_ms": 313.84, + "duration_p50_ms": 303.03, + "duration_p99_ms": 313.84, + "duration_std_ms": 4.19, + "throughput_avg_mbps": 5919.57, + "throughput_min_mbps": 5709.96, + "throughput_max_mbps": 6080.67, + "ops_per_sec_avg": 422.83, + "latency_per_key_ms": 2.365 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.cpu new file mode 100644 index 0000000..8c5adb9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 42.95979142189026, "user_s": 96.371563, "sys_s": 26.405862, "max_rss_kb": 4042876} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.json new file mode 100644 index 0000000..24b4728 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 359.61, + "duration_min_ms": 323.55, + "duration_max_ms": 399.25, + "duration_p50_ms": 362.35, + "duration_p99_ms": 399.25, + "duration_std_ms": 18.47, + "throughput_avg_mbps": 4996.37, + "throughput_min_mbps": 4488.47, + "throughput_max_mbps": 5538.5, + "ops_per_sec_avg": 356.88, + "latency_per_key_ms": 2.809 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 1.84, + "duration_min_ms": 1.62, + "duration_max_ms": 2.88, + "duration_p50_ms": 1.69, + "duration_p99_ms": 2.88, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 70766.07, + "latency_per_key_ms": 0.014 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 277.64, + "duration_min_ms": 275.8, + "duration_max_ms": 280.69, + "duration_p50_ms": 277.51, + "duration_p99_ms": 280.69, + "duration_std_ms": 1.07, + "throughput_avg_mbps": 6454.4, + "throughput_min_mbps": 6384.32, + "throughput_max_mbps": 6497.35, + "ops_per_sec_avg": 461.03, + "latency_per_key_ms": 2.169 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.cpu new file mode 100644 index 0000000..5e68dc6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.17409658432007, "user_s": 96.511259, "sys_s": 26.486069, "max_rss_kb": 4045408} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.json new file mode 100644 index 0000000..7393519 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 363.59, + "duration_min_ms": 321.55, + "duration_max_ms": 427.4, + "duration_p50_ms": 363.18, + "duration_p99_ms": 427.4, + "duration_std_ms": 26.2, + "throughput_avg_mbps": 4953.52, + "throughput_min_mbps": 4192.81, + "throughput_max_mbps": 5573.05, + "ops_per_sec_avg": 353.82, + "latency_per_key_ms": 2.841 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 2.64, + "duration_min_ms": 2.53, + "duration_max_ms": 2.81, + "duration_p50_ms": 2.64, + "duration_p99_ms": 2.81, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48520.15, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 276.75, + "duration_min_ms": 275.23, + "duration_max_ms": 278.84, + "duration_p50_ms": 276.67, + "duration_p99_ms": 278.84, + "duration_std_ms": 0.9, + "throughput_avg_mbps": 6475.13, + "throughput_min_mbps": 6426.53, + "throughput_max_mbps": 6510.89, + "ops_per_sec_avg": 462.51, + "latency_per_key_ms": 2.162 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.cpu new file mode 100644 index 0000000..b7385d1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 43.416934967041016, "user_s": 97.233937, "sys_s": 25.920277, "max_rss_kb": 4045012} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.json new file mode 100644 index 0000000..8ce92ca --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if16/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 366.04, + "duration_min_ms": 324.89, + "duration_max_ms": 438.83, + "duration_p50_ms": 364.15, + "duration_p99_ms": 438.83, + "duration_std_ms": 25.35, + "throughput_avg_mbps": 4918.37, + "throughput_min_mbps": 4083.59, + "throughput_max_mbps": 5515.65, + "ops_per_sec_avg": 351.31, + "latency_per_key_ms": 2.86 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 2.77, + "duration_min_ms": 2.5, + "duration_max_ms": 3.09, + "duration_p50_ms": 2.82, + "duration_p99_ms": 3.09, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46389.31, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 277.5, + "duration_min_ms": 275.92, + "duration_max_ms": 279.82, + "duration_p50_ms": 277.43, + "duration_p99_ms": 279.82, + "duration_std_ms": 0.8, + "throughput_avg_mbps": 6457.77, + "throughput_min_mbps": 6404.16, + "throughput_max_mbps": 6494.61, + "ops_per_sec_avg": 461.27, + "latency_per_key_ms": 2.168 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.cpu new file mode 100644 index 0000000..5e26fcc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.69043731689453, "user_s": 101.980895, "sys_s": 22.237571, "max_rss_kb": 1295972} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.json new file mode 100644 index 0000000..802a476 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 92.21, + "duration_min_ms": 79.92, + "duration_max_ms": 138.68, + "duration_p50_ms": 92.32, + "duration_p99_ms": 110.7, + "duration_std_ms": 8.53, + "throughput_avg_mbps": 4895.47, + "throughput_min_mbps": 3230.54, + "throughput_max_mbps": 5605.43, + "ops_per_sec_avg": 349.68, + "latency_per_key_ms": 2.882 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.26, + "duration_min_ms": 0.21, + "duration_max_ms": 0.3, + "duration_p50_ms": 0.28, + "duration_p99_ms": 0.29, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 123590.94, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 75.77, + "duration_min_ms": 73.69, + "duration_max_ms": 79.11, + "duration_p50_ms": 75.68, + "duration_p99_ms": 79.0, + "duration_std_ms": 1.12, + "throughput_avg_mbps": 5913.93, + "throughput_min_mbps": 5663.23, + "throughput_max_mbps": 6079.29, + "ops_per_sec_avg": 422.42, + "latency_per_key_ms": 2.368 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.cpu new file mode 100644 index 0000000..99bdfdb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.58189558982849, "user_s": 102.502235, "sys_s": 21.45388, "max_rss_kb": 1292488} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.json new file mode 100644 index 0000000..c0848a1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 92.72, + "duration_min_ms": 80.29, + "duration_max_ms": 148.68, + "duration_p50_ms": 92.19, + "duration_p99_ms": 136.71, + "duration_std_ms": 9.58, + "throughput_avg_mbps": 4874.01, + "throughput_min_mbps": 3013.12, + "throughput_max_mbps": 5579.44, + "ops_per_sec_avg": 348.14, + "latency_per_key_ms": 2.898 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.26, + "duration_min_ms": 0.21, + "duration_max_ms": 0.3, + "duration_p50_ms": 0.27, + "duration_p99_ms": 0.3, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 125483.5, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 74.19, + "duration_min_ms": 71.61, + "duration_max_ms": 76.26, + "duration_p50_ms": 74.15, + "duration_p99_ms": 76.24, + "duration_std_ms": 0.97, + "throughput_avg_mbps": 6039.26, + "throughput_min_mbps": 5874.68, + "throughput_max_mbps": 6256.11, + "ops_per_sec_avg": 431.38, + "latency_per_key_ms": 2.319 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.cpu new file mode 100644 index 0000000..5c3c3cc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.729273557662964, "user_s": 102.645762, "sys_s": 20.916197, "max_rss_kb": 1295264} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.json new file mode 100644 index 0000000..c6be779 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/raw_uring_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 92.64, + "duration_min_ms": 80.44, + "duration_max_ms": 134.21, + "duration_p50_ms": 91.03, + "duration_p99_ms": 131.55, + "duration_std_ms": 9.58, + "throughput_avg_mbps": 4880.32, + "throughput_min_mbps": 3338.06, + "throughput_max_mbps": 5569.48, + "ops_per_sec_avg": 348.59, + "latency_per_key_ms": 2.895 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.25, + "duration_min_ms": 0.21, + "duration_max_ms": 0.3, + "duration_p50_ms": 0.27, + "duration_p99_ms": 0.28, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 127071.36, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 75.62, + "duration_min_ms": 72.77, + "duration_max_ms": 82.46, + "duration_p50_ms": 75.45, + "duration_p99_ms": 80.42, + "duration_std_ms": 1.65, + "throughput_avg_mbps": 5927.06, + "throughput_min_mbps": 5432.94, + "throughput_max_mbps": 6156.4, + "ops_per_sec_avg": 423.36, + "latency_per_key_ms": 2.363 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.cpu new file mode 100644 index 0000000..5e62703 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.754099369049072, "user_s": 111.439027, "sys_s": 13.093415, "max_rss_kb": 1292700} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.json new file mode 100644 index 0000000..69039b7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 91.89, + "duration_min_ms": 79.7, + "duration_max_ms": 160.74, + "duration_p50_ms": 90.88, + "duration_p99_ms": 120.99, + "duration_std_ms": 10.28, + "throughput_avg_mbps": 4923.74, + "throughput_min_mbps": 2787.09, + "throughput_max_mbps": 5621.19, + "ops_per_sec_avg": 351.7, + "latency_per_key_ms": 2.872 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.72, + "duration_min_ms": 0.68, + "duration_max_ms": 0.77, + "duration_p50_ms": 0.71, + "duration_p99_ms": 0.76, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 44705.8, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 70.81, + "duration_min_ms": 69.19, + "duration_max_ms": 73.11, + "duration_p50_ms": 70.72, + "duration_p99_ms": 72.69, + "duration_std_ms": 0.8, + "throughput_avg_mbps": 6327.89, + "throughput_min_mbps": 6128.11, + "throughput_max_mbps": 6474.85, + "ops_per_sec_avg": 451.99, + "latency_per_key_ms": 2.213 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.cpu new file mode 100644 index 0000000..d7cfa2f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.69029402732849, "user_s": 110.518141, "sys_s": 13.031892, "max_rss_kb": 1289580} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.json new file mode 100644 index 0000000..b9825d6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 91.9, + "duration_min_ms": 79.69, + "duration_max_ms": 149.44, + "duration_p50_ms": 91.11, + "duration_p99_ms": 121.24, + "duration_std_ms": 9.29, + "throughput_avg_mbps": 4916.67, + "throughput_min_mbps": 2997.79, + "throughput_max_mbps": 5621.62, + "ops_per_sec_avg": 351.19, + "latency_per_key_ms": 2.872 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.73, + "duration_min_ms": 0.66, + "duration_max_ms": 0.88, + "duration_p50_ms": 0.72, + "duration_p99_ms": 0.81, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 43994.23, + "latency_per_key_ms": 0.023 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 70.62, + "duration_min_ms": 69.03, + "duration_max_ms": 73.43, + "duration_p50_ms": 70.54, + "duration_p99_ms": 72.31, + "duration_std_ms": 0.79, + "throughput_avg_mbps": 6344.61, + "throughput_min_mbps": 6100.75, + "throughput_max_mbps": 6489.63, + "ops_per_sec_avg": 453.19, + "latency_per_key_ms": 2.207 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.cpu new file mode 100644 index 0000000..b7b75a3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.851499795913696, "user_s": 116.90941, "sys_s": 13.220076, "max_rss_kb": 1291332} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.json new file mode 100644 index 0000000..e1f64fe --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/one_if4/rust_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 4, + "keys_per_round": 32, + "data_size_kb": 14336, + "data_per_round_mb": 448.0, + "measurement_rounds": 112, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 91.88, + "duration_min_ms": 82.17, + "duration_max_ms": 134.25, + "duration_p50_ms": 90.76, + "duration_p99_ms": 109.07, + "duration_std_ms": 8.23, + "throughput_avg_mbps": 4911.21, + "throughput_min_mbps": 3337.11, + "throughput_max_mbps": 5452.4, + "ops_per_sec_avg": 350.8, + "latency_per_key_ms": 2.871 + }, + "op_1": { + "operation": "Lookup", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 0, + "duration_avg_ms": 0.71, + "duration_min_ms": 0.65, + "duration_max_ms": 0.8, + "duration_p50_ms": 0.72, + "duration_p99_ms": 0.77, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 44871.5, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 112, + "rounds_timed_out": 0, + "keys_per_round": 32, + "total_keys": 3584, + "total_success": 3584, + "duration_avg_ms": 70.88, + "duration_min_ms": 69.5, + "duration_max_ms": 73.07, + "duration_p50_ms": 70.77, + "duration_p99_ms": 72.85, + "duration_std_ms": 0.8, + "throughput_avg_mbps": 6321.55, + "throughput_min_mbps": 6131.4, + "throughput_max_mbps": 6446.27, + "ops_per_sec_avg": 451.54, + "latency_per_key_ms": 2.215 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.cpu new file mode 100644 index 0000000..8f38e5a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 10.553839445114136, "user_s": 19.141456, "sys_s": 9.182707, "max_rss_kb": 4046044} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.json new file mode 100644 index 0000000..f903e90 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_posix-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":16,\"num_load_workers\":16,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 8, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 366.85, + "duration_min_ms": 332.56, + "duration_max_ms": 404.44, + "duration_p50_ms": 367.65, + "duration_p99_ms": 404.44, + "duration_std_ms": 23.63, + "throughput_avg_mbps": 4902.76, + "throughput_min_mbps": 4430.85, + "throughput_max_mbps": 5388.49, + "ops_per_sec_avg": 350.2, + "latency_per_key_ms": 2.866 + }, + "op_1": { + "operation": "Lookup", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 0, + "duration_avg_ms": 0.75, + "duration_min_ms": 0.72, + "duration_max_ms": 0.81, + "duration_p50_ms": 0.74, + "duration_p99_ms": 0.81, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 171102.77, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 311.92, + "duration_min_ms": 299.65, + "duration_max_ms": 322.1, + "duration_p50_ms": 309.84, + "duration_p99_ms": 322.1, + "duration_std_ms": 7.87, + "throughput_avg_mbps": 5748.3, + "throughput_min_mbps": 5563.41, + "throughput_max_mbps": 5980.35, + "ops_per_sec_avg": 410.59, + "latency_per_key_ms": 2.437 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.cpu new file mode 100644 index 0000000..a8fa40c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 10.446219682693481, "user_s": 22.550627, "sys_s": 12.746536, "max_rss_kb": 4045960} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.json new file mode 100644 index 0000000..69fde2f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/rb_uring-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/nvme1n1\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":16,\"num_load_workers\":16,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 8, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 360.05, + "duration_min_ms": 336.08, + "duration_max_ms": 381.38, + "duration_p50_ms": 367.63, + "duration_p99_ms": 381.38, + "duration_std_ms": 18.12, + "throughput_avg_mbps": 4988.29, + "throughput_min_mbps": 4698.73, + "throughput_max_mbps": 5332.02, + "ops_per_sec_avg": 356.31, + "latency_per_key_ms": 2.813 + }, + "op_1": { + "operation": "Lookup", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 0, + "duration_avg_ms": 0.68, + "duration_min_ms": 0.67, + "duration_max_ms": 0.72, + "duration_p50_ms": 0.68, + "duration_p99_ms": 0.72, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 187477.07, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 310.7, + "duration_min_ms": 293.89, + "duration_max_ms": 350.69, + "duration_p50_ms": 308.21, + "duration_p99_ms": 350.69, + "duration_std_ms": 18.55, + "throughput_avg_mbps": 5784.6, + "throughput_min_mbps": 5109.93, + "throughput_max_mbps": 6097.49, + "ops_per_sec_avg": 413.19, + "latency_per_key_ms": 2.427 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.cpu new file mode 100644 index 0000000..b7bb237 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 10.932765245437622, "user_s": 20.72679, "sys_s": 9.233447, "max_rss_kb": 4043604} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.json new file mode 100644 index 0000000..4f42d95 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d1-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 8, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 360.79, + "duration_min_ms": 333.74, + "duration_max_ms": 380.36, + "duration_p50_ms": 363.17, + "duration_p99_ms": 380.36, + "duration_std_ms": 17.16, + "throughput_avg_mbps": 4977.0, + "throughput_min_mbps": 4711.27, + "throughput_max_mbps": 5369.37, + "ops_per_sec_avg": 355.5, + "latency_per_key_ms": 2.819 + }, + "op_1": { + "operation": "Lookup", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 0, + "duration_avg_ms": 2.65, + "duration_min_ms": 2.5, + "duration_max_ms": 3.0, + "duration_p50_ms": 2.56, + "duration_p99_ms": 3.0, + "duration_std_ms": 0.17, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48443.11, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 8, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 1024, + "total_success": 1024, + "duration_avg_ms": 302.38, + "duration_min_ms": 299.23, + "duration_max_ms": 305.46, + "duration_p50_ms": 300.77, + "duration_p99_ms": 305.46, + "duration_std_ms": 2.31, + "throughput_avg_mbps": 5926.65, + "throughput_min_mbps": 5866.49, + "throughput_max_mbps": 5988.7, + "ops_per_sec_avg": 423.33, + "latency_per_key_ms": 2.362 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.cpu new file mode 100644 index 0000000..9952c9a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 8.78717589378357, "user_s": 33.045352, "sys_s": 12.109475, "max_rss_kb": 4040804} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.json new file mode 100644 index 0000000..9daedb2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_d4-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 2048, + "duration_avg_ms": 120.24, + "duration_min_ms": 113.69, + "duration_max_ms": 130.24, + "duration_p50_ms": 118.93, + "duration_p99_ms": 130.24, + "duration_std_ms": 4.48, + "throughput_avg_mbps": 14922.64, + "throughput_min_mbps": 13759.14, + "throughput_max_mbps": 15762.11, + "ops_per_sec_avg": 1065.9, + "latency_per_key_ms": 0.939 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 0, + "duration_avg_ms": 2.94, + "duration_min_ms": 2.62, + "duration_max_ms": 3.21, + "duration_p50_ms": 2.94, + "duration_p99_ms": 3.21, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 43634.06, + "latency_per_key_ms": 0.023 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 2048, + "duration_avg_ms": 96.65, + "duration_min_ms": 92.45, + "duration_max_ms": 104.61, + "duration_p50_ms": 95.76, + "duration_p99_ms": 104.61, + "duration_std_ms": 3.23, + "throughput_avg_mbps": 18560.53, + "throughput_min_mbps": 17129.49, + "throughput_max_mbps": 19383.16, + "ops_per_sec_avg": 1325.75, + "latency_per_key_ms": 0.755 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.cpu new file mode 100644 index 0000000..e69b3d8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 5.748389482498169, "user_s": 33.620653, "sys_s": 46.816285, "max_rss_kb": 4047708} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.json new file mode 100644 index 0000000..089062d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/pilot/ru_ram-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 2048, + "duration_avg_ms": 63.3, + "duration_min_ms": 61.99, + "duration_max_ms": 65.39, + "duration_p50_ms": 62.97, + "duration_p99_ms": 65.39, + "duration_std_ms": 1.06, + "throughput_avg_mbps": 28315.48, + "throughput_min_mbps": 27403.69, + "throughput_max_mbps": 28908.05, + "ops_per_sec_avg": 2022.53, + "latency_per_key_ms": 0.495 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 0, + "duration_avg_ms": 1.11, + "duration_min_ms": 1.01, + "duration_max_ms": 1.51, + "duration_p50_ms": 1.07, + "duration_p99_ms": 1.51, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 117170.58, + "latency_per_key_ms": 0.009 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 2048, + "total_success": 2048, + "duration_avg_ms": 33.36, + "duration_min_ms": 29.34, + "duration_max_ms": 40.6, + "duration_p50_ms": 32.22, + "duration_p99_ms": 40.6, + "duration_std_ms": 2.87, + "throughput_avg_mbps": 54061.41, + "throughput_min_mbps": 44132.61, + "throughput_max_mbps": 61081.1, + "ops_per_sec_avg": 3861.53, + "latency_per_key_ms": 0.261 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.cpu new file mode 100644 index 0000000..29e9da8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.04406690597534, "user_s": 189.739565, "sys_s": 146.262832, "max_rss_kb": 15072988} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.json new file mode 100644 index 0000000..ad42382 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 745.43, + "duration_min_ms": 679.2, + "duration_max_ms": 821.23, + "duration_p50_ms": 739.74, + "duration_p99_ms": 821.23, + "duration_std_ms": 44.79, + "throughput_avg_mbps": 9648.99, + "throughput_min_mbps": 8728.35, + "throughput_max_mbps": 10553.64, + "ops_per_sec_avg": 689.21, + "latency_per_key_ms": 1.456 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.84, + "duration_min_ms": 3.01, + "duration_max_ms": 4.52, + "duration_p50_ms": 3.89, + "duration_p99_ms": 4.52, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 134072.43, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 665.36, + "duration_min_ms": 608.92, + "duration_max_ms": 729.69, + "duration_p50_ms": 657.52, + "duration_p99_ms": 729.69, + "duration_std_ms": 30.1, + "throughput_avg_mbps": 10793.99, + "throughput_min_mbps": 9823.34, + "throughput_max_mbps": 11771.65, + "ops_per_sec_avg": 771.0, + "latency_per_key_ms": 1.3 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.cpu new file mode 100644 index 0000000..2c5ef3b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.248321771621704, "user_s": 181.772158, "sys_s": 145.193009, "max_rss_kb": 15076380} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.json new file mode 100644 index 0000000..285f8e8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 744.36, + "duration_min_ms": 679.14, + "duration_max_ms": 1045.22, + "duration_p50_ms": 720.45, + "duration_p99_ms": 1045.22, + "duration_std_ms": 71.97, + "throughput_avg_mbps": 9700.69, + "throughput_min_mbps": 6857.89, + "throughput_max_mbps": 10554.6, + "ops_per_sec_avg": 692.91, + "latency_per_key_ms": 1.454 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.84, + "duration_min_ms": 2.98, + "duration_max_ms": 4.5, + "duration_p50_ms": 3.89, + "duration_p99_ms": 4.5, + "duration_std_ms": 0.28, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 134294.3, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 672.14, + "duration_min_ms": 633.56, + "duration_max_ms": 722.38, + "duration_p50_ms": 669.37, + "duration_p99_ms": 722.38, + "duration_std_ms": 23.15, + "throughput_avg_mbps": 10676.52, + "throughput_min_mbps": 9922.72, + "throughput_max_mbps": 11313.93, + "ops_per_sec_avg": 762.61, + "latency_per_key_ms": 1.313 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.cpu new file mode 100644 index 0000000..0f111d0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.12757921218872, "user_s": 183.231295, "sys_s": 152.097606, "max_rss_kb": 15077376} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.json new file mode 100644 index 0000000..0b7b2ab --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 742.97, + "duration_min_ms": 687.38, + "duration_max_ms": 793.83, + "duration_p50_ms": 737.96, + "duration_p99_ms": 793.83, + "duration_std_ms": 35.62, + "throughput_avg_mbps": 9669.27, + "throughput_min_mbps": 9029.68, + "throughput_max_mbps": 10427.93, + "ops_per_sec_avg": 690.66, + "latency_per_key_ms": 1.451 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.9, + "duration_min_ms": 3.06, + "duration_max_ms": 4.57, + "duration_p50_ms": 3.95, + "duration_p99_ms": 4.57, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 132120.03, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 669.63, + "duration_min_ms": 610.48, + "duration_max_ms": 741.39, + "duration_p50_ms": 665.29, + "duration_p99_ms": 741.39, + "duration_std_ms": 31.33, + "throughput_avg_mbps": 10726.63, + "throughput_min_mbps": 9668.28, + "throughput_max_mbps": 11741.5, + "ops_per_sec_avg": 766.19, + "latency_per_key_ms": 1.308 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.cpu new file mode 100644 index 0000000..5d0a07a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.30622625350952, "user_s": 223.080212, "sys_s": 195.818094, "max_rss_kb": 15079252} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.json new file mode 100644 index 0000000..c5a8b1f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 732.57, + "duration_min_ms": 677.81, + "duration_max_ms": 788.33, + "duration_p50_ms": 731.03, + "duration_p99_ms": 788.33, + "duration_std_ms": 34.32, + "throughput_avg_mbps": 9805.45, + "throughput_min_mbps": 9092.66, + "throughput_max_mbps": 10575.19, + "ops_per_sec_avg": 700.39, + "latency_per_key_ms": 1.431 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.88, + "duration_min_ms": 3.03, + "duration_max_ms": 4.02, + "duration_p50_ms": 3.93, + "duration_p99_ms": 4.02, + "duration_std_ms": 0.24, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 132554.34, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 617.94, + "duration_min_ms": 597.58, + "duration_max_ms": 663.63, + "duration_p50_ms": 614.35, + "duration_p99_ms": 663.63, + "duration_std_ms": 14.3, + "throughput_avg_mbps": 11605.67, + "throughput_min_mbps": 10801.24, + "throughput_max_mbps": 11995.04, + "ops_per_sec_avg": 828.98, + "latency_per_key_ms": 1.207 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.cpu new file mode 100644 index 0000000..bfb74f2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.53456902503967, "user_s": 219.759397, "sys_s": 195.09639, "max_rss_kb": 15077264} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.json new file mode 100644 index 0000000..4a88238 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 731.98, + "duration_min_ms": 679.01, + "duration_max_ms": 796.85, + "duration_p50_ms": 723.0, + "duration_p99_ms": 796.85, + "duration_std_ms": 31.56, + "throughput_avg_mbps": 9810.09, + "throughput_min_mbps": 8995.44, + "throughput_max_mbps": 10556.51, + "ops_per_sec_avg": 700.72, + "latency_per_key_ms": 1.43 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.88, + "duration_min_ms": 3.01, + "duration_max_ms": 4.06, + "duration_p50_ms": 3.94, + "duration_p99_ms": 4.06, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 132752.96, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 626.98, + "duration_min_ms": 608.33, + "duration_max_ms": 670.25, + "duration_p50_ms": 620.48, + "duration_p99_ms": 670.25, + "duration_std_ms": 15.65, + "throughput_avg_mbps": 11439.24, + "throughput_min_mbps": 10694.49, + "throughput_max_mbps": 11783.0, + "ops_per_sec_avg": 817.09, + "latency_per_key_ms": 1.225 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.cpu new file mode 100644 index 0000000..bea4eef --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 48.283573389053345, "user_s": 218.642064, "sys_s": 192.488505, "max_rss_kb": 15078512} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.json new file mode 100644 index 0000000..c81cfd2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d2_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 730.75, + "duration_min_ms": 680.85, + "duration_max_ms": 792.05, + "duration_p50_ms": 732.48, + "duration_p99_ms": 792.05, + "duration_std_ms": 35.15, + "throughput_avg_mbps": 9830.96, + "throughput_min_mbps": 9049.94, + "throughput_max_mbps": 10528.0, + "ops_per_sec_avg": 702.21, + "latency_per_key_ms": 1.427 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 3.71, + "duration_min_ms": 2.81, + "duration_max_ms": 4.07, + "duration_p50_ms": 3.82, + "duration_p99_ms": 4.07, + "duration_std_ms": 0.33, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 139428.25, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 621.01, + "duration_min_ms": 601.12, + "duration_max_ms": 670.39, + "duration_p50_ms": 617.59, + "duration_p99_ms": 670.39, + "duration_std_ms": 13.67, + "throughput_avg_mbps": 11547.78, + "throughput_min_mbps": 10692.23, + "throughput_max_mbps": 11924.35, + "ops_per_sec_avg": 824.84, + "latency_per_key_ms": 1.213 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.cpu new file mode 100644 index 0000000..4c97b1d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.81322407722473, "user_s": 298.361933, "sys_s": 194.110016, "max_rss_kb": 15093072} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.json new file mode 100644 index 0000000..b12044b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 387.67, + "duration_min_ms": 365.69, + "duration_max_ms": 478.43, + "duration_p50_ms": 382.08, + "duration_p99_ms": 478.43, + "duration_std_ms": 19.96, + "throughput_avg_mbps": 18533.63, + "throughput_min_mbps": 14982.31, + "throughput_max_mbps": 19601.51, + "ops_per_sec_avg": 1323.83, + "latency_per_key_ms": 0.757 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.87, + "duration_min_ms": 3.03, + "duration_max_ms": 4.03, + "duration_p50_ms": 3.89, + "duration_p99_ms": 4.03, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 132438.72, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 311.65, + "duration_min_ms": 284.02, + "duration_max_ms": 362.82, + "duration_p50_ms": 308.2, + "duration_p99_ms": 362.82, + "duration_std_ms": 13.94, + "throughput_avg_mbps": 23041.78, + "throughput_min_mbps": 19756.32, + "throughput_max_mbps": 25237.51, + "ops_per_sec_avg": 1645.84, + "latency_per_key_ms": 0.609 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.cpu new file mode 100644 index 0000000..18e42ac --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 62.49143958091736, "user_s": 313.240899, "sys_s": 141.820924, "max_rss_kb": 15091468} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.json new file mode 100644 index 0000000..19b96c4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 430.7, + "duration_min_ms": 427.09, + "duration_max_ms": 446.05, + "duration_p50_ms": 428.49, + "duration_p99_ms": 446.05, + "duration_std_ms": 5.05, + "throughput_avg_mbps": 16644.71, + "throughput_min_mbps": 16069.92, + "throughput_max_mbps": 16783.32, + "ops_per_sec_avg": 1188.91, + "latency_per_key_ms": 0.841 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.79, + "duration_min_ms": 2.8, + "duration_max_ms": 3.93, + "duration_p50_ms": 3.85, + "duration_p99_ms": 3.93, + "duration_std_ms": 0.24, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 135657.5, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 471.83, + "duration_min_ms": 469.35, + "duration_max_ms": 476.18, + "duration_p50_ms": 471.34, + "duration_p99_ms": 476.18, + "duration_std_ms": 1.85, + "throughput_avg_mbps": 15192.15, + "throughput_min_mbps": 15053.02, + "throughput_max_mbps": 15272.04, + "ops_per_sec_avg": 1085.15, + "latency_per_key_ms": 0.922 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.cpu new file mode 100644 index 0000000..589ba0d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.77891182899475, "user_s": 297.185956, "sys_s": 166.974462, "max_rss_kb": 15093768} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.json new file mode 100644 index 0000000..c1d190e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":32,\"num_load_workers\":32,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 425.75, + "duration_min_ms": 376.82, + "duration_max_ms": 465.99, + "duration_p50_ms": 426.48, + "duration_p99_ms": 465.99, + "duration_std_ms": 13.98, + "throughput_avg_mbps": 16854.64, + "throughput_min_mbps": 15382.21, + "throughput_max_mbps": 19022.2, + "ops_per_sec_avg": 1203.9, + "latency_per_key_ms": 0.832 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.96, + "duration_min_ms": 3.02, + "duration_max_ms": 4.04, + "duration_p50_ms": 3.98, + "duration_p99_ms": 4.04, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 129347.04, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 290.23, + "duration_min_ms": 278.9, + "duration_max_ms": 333.63, + "duration_p50_ms": 288.73, + "duration_p99_ms": 333.63, + "duration_std_ms": 9.44, + "throughput_avg_mbps": 24721.33, + "throughput_min_mbps": 21485.09, + "throughput_max_mbps": 25701.4, + "ops_per_sec_avg": 1765.81, + "latency_per_key_ms": 0.567 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.cpu new file mode 100644 index 0000000..e5c88b6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 62.11882519721985, "user_s": 345.824633, "sys_s": 155.244743, "max_rss_kb": 15094620} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.json new file mode 100644 index 0000000..958c46d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 423.67, + "duration_min_ms": 416.66, + "duration_max_ms": 537.42, + "duration_p50_ms": 418.47, + "duration_p99_ms": 537.42, + "duration_std_ms": 16.59, + "throughput_avg_mbps": 16939.6, + "throughput_min_mbps": 13337.86, + "throughput_max_mbps": 17203.31, + "ops_per_sec_avg": 1209.97, + "latency_per_key_ms": 0.827 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.91, + "duration_min_ms": 3.05, + "duration_max_ms": 4.39, + "duration_p50_ms": 3.95, + "duration_p99_ms": 4.39, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 131594.2, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 470.49, + "duration_min_ms": 467.42, + "duration_max_ms": 476.6, + "duration_p50_ms": 469.49, + "duration_p99_ms": 476.6, + "duration_std_ms": 2.57, + "throughput_avg_mbps": 15235.53, + "throughput_min_mbps": 15040.01, + "throughput_max_mbps": 15335.2, + "ops_per_sec_avg": 1088.25, + "latency_per_key_ms": 0.919 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.cpu new file mode 100644 index 0000000..6d896d2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 62.12756609916687, "user_s": 343.949357, "sys_s": 158.550401, "max_rss_kb": 15097284} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.json new file mode 100644 index 0000000..6b582f6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 426.74, + "duration_min_ms": 418.43, + "duration_max_ms": 509.81, + "duration_p50_ms": 420.69, + "duration_p99_ms": 509.81, + "duration_std_ms": 13.61, + "throughput_avg_mbps": 16811.84, + "throughput_min_mbps": 14060.01, + "throughput_max_mbps": 17130.87, + "ops_per_sec_avg": 1200.85, + "latency_per_key_ms": 0.833 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.86, + "duration_min_ms": 2.8, + "duration_max_ms": 4.04, + "duration_p50_ms": 3.96, + "duration_p99_ms": 4.04, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 133761.43, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 467.77, + "duration_min_ms": 466.41, + "duration_max_ms": 469.4, + "duration_p50_ms": 467.91, + "duration_p99_ms": 469.4, + "duration_std_ms": 0.64, + "throughput_avg_mbps": 15323.64, + "throughput_min_mbps": 15270.63, + "throughput_max_mbps": 15368.56, + "ops_per_sec_avg": 1094.55, + "latency_per_key_ms": 0.914 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.cpu new file mode 100644 index 0000000..b9009e1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 62.92986583709717, "user_s": 321.223598, "sys_s": 189.255456, "max_rss_kb": 15099240} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.json new file mode 100644 index 0000000..c5bfb97 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/raid0/raw_uring_d4_w64-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/md127\",\"slot_bytes\":14684160,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":64,\"num_load_workers\":64,\"io_engine\":\"io_uring\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 435.61, + "duration_min_ms": 416.99, + "duration_max_ms": 551.09, + "duration_p50_ms": 430.3, + "duration_p99_ms": 551.09, + "duration_std_ms": 18.11, + "throughput_avg_mbps": 16478.54, + "throughput_min_mbps": 13006.95, + "throughput_max_mbps": 17189.78, + "ops_per_sec_avg": 1177.04, + "latency_per_key_ms": 0.851 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 3.88, + "duration_min_ms": 2.89, + "duration_max_ms": 4.21, + "duration_p50_ms": 3.9, + "duration_p99_ms": 4.21, + "duration_std_ms": 0.29, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 133010.07, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 472.75, + "duration_min_ms": 467.11, + "duration_max_ms": 477.04, + "duration_p50_ms": 474.38, + "duration_p99_ms": 477.04, + "duration_std_ms": 3.4, + "throughput_avg_mbps": 15163.27, + "throughput_min_mbps": 15025.84, + "throughput_max_mbps": 15345.42, + "ops_per_sec_avg": 1083.09, + "latency_per_key_ms": 0.923 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.cpu new file mode 100644 index 0000000..f821165 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.842469453811646, "user_s": 89.975086, "sys_s": 45.827978, "max_rss_kb": 15055452} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.json new file mode 100644 index 0000000..1a450cc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1461.98, + "duration_min_ms": 1435.29, + "duration_max_ms": 1483.14, + "duration_p50_ms": 1463.39, + "duration_p99_ms": 1483.14, + "duration_std_ms": 14.79, + "throughput_avg_mbps": 4903.41, + "throughput_min_mbps": 4833.0, + "throughput_max_mbps": 4994.1, + "ops_per_sec_avg": 350.24, + "latency_per_key_ms": 2.855 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 10.63, + "duration_min_ms": 10.1, + "duration_max_ms": 11.44, + "duration_p50_ms": 10.42, + "duration_p99_ms": 11.44, + "duration_std_ms": 0.46, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48238.1, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1206.35, + "duration_min_ms": 1179.72, + "duration_max_ms": 1262.62, + "duration_p50_ms": 1194.27, + "duration_p99_ms": 1262.62, + "duration_std_ms": 27.33, + "throughput_avg_mbps": 5944.68, + "throughput_min_mbps": 5677.1, + "throughput_max_mbps": 6076.03, + "ops_per_sec_avg": 424.62, + "latency_per_key_ms": 2.356 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.cpu new file mode 100644 index 0000000..a3fd98b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.98090314865112, "user_s": 90.798855, "sys_s": 45.768438, "max_rss_kb": 15058536} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.json new file mode 100644 index 0000000..12185b0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1432.95, + "duration_min_ms": 1400.52, + "duration_max_ms": 1451.84, + "duration_p50_ms": 1434.58, + "duration_p99_ms": 1451.84, + "duration_std_ms": 13.59, + "throughput_avg_mbps": 5002.7, + "throughput_min_mbps": 4937.18, + "throughput_max_mbps": 5118.09, + "ops_per_sec_avg": 357.34, + "latency_per_key_ms": 2.799 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 9.98, + "duration_min_ms": 9.8, + "duration_max_ms": 10.1, + "duration_p50_ms": 10.0, + "duration_p99_ms": 10.1, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 51285.48, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1237.79, + "duration_min_ms": 1194.09, + "duration_max_ms": 1283.38, + "duration_p50_ms": 1221.46, + "duration_p99_ms": 1283.38, + "duration_std_ms": 33.72, + "throughput_avg_mbps": 5794.94, + "throughput_min_mbps": 5585.23, + "throughput_max_mbps": 6002.92, + "ops_per_sec_avg": 413.92, + "latency_per_key_ms": 2.418 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.cpu new file mode 100644 index 0000000..123f006 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.08941960334778, "user_s": 89.122446, "sys_s": 45.743094, "max_rss_kb": 15056996} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.json new file mode 100644 index 0000000..d674e7a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d1_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1447.64, + "duration_min_ms": 1424.62, + "duration_max_ms": 1476.6, + "duration_p50_ms": 1445.91, + "duration_p99_ms": 1476.6, + "duration_std_ms": 14.87, + "throughput_avg_mbps": 4952.0, + "throughput_min_mbps": 4854.38, + "throughput_max_mbps": 5031.53, + "ops_per_sec_avg": 353.71, + "latency_per_key_ms": 2.827 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 10.46, + "duration_min_ms": 10.08, + "duration_max_ms": 11.38, + "duration_p50_ms": 10.28, + "duration_p99_ms": 11.38, + "duration_std_ms": 0.38, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48995.0, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1237.97, + "duration_min_ms": 1202.28, + "duration_max_ms": 1276.86, + "duration_p50_ms": 1236.0, + "duration_p99_ms": 1276.86, + "duration_std_ms": 19.06, + "throughput_avg_mbps": 5791.41, + "throughput_min_mbps": 5613.78, + "throughput_max_mbps": 5962.01, + "ops_per_sec_avg": 413.67, + "latency_per_key_ms": 2.418 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.cpu new file mode 100644 index 0000000..2c27d4b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 54.15001153945923, "user_s": 158.75845, "sys_s": 64.323758, "max_rss_kb": 15058436} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.json new file mode 100644 index 0000000..00910b6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 836.37, + "duration_min_ms": 774.49, + "duration_max_ms": 940.96, + "duration_p50_ms": 813.56, + "duration_p99_ms": 940.96, + "duration_std_ms": 50.31, + "throughput_avg_mbps": 8600.07, + "throughput_min_mbps": 7617.72, + "throughput_max_mbps": 9255.09, + "ops_per_sec_avg": 614.29, + "latency_per_key_ms": 1.634 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 9.99, + "duration_min_ms": 9.81, + "duration_max_ms": 10.28, + "duration_p50_ms": 9.97, + "duration_p99_ms": 10.28, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 51233.97, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 687.72, + "duration_min_ms": 674.91, + "duration_max_ms": 714.58, + "duration_p50_ms": 686.3, + "duration_p99_ms": 714.58, + "duration_std_ms": 9.84, + "throughput_avg_mbps": 10424.9, + "throughput_min_mbps": 10031.12, + "throughput_max_mbps": 10620.7, + "ops_per_sec_avg": 744.64, + "latency_per_key_ms": 1.343 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.cpu new file mode 100644 index 0000000..0b65aaf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 54.0958411693573, "user_s": 158.218425, "sys_s": 65.361795, "max_rss_kb": 15058524} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.json new file mode 100644 index 0000000..a3b28a6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 825.58, + "duration_min_ms": 798.1, + "duration_max_ms": 866.0, + "duration_p50_ms": 825.87, + "duration_p99_ms": 866.0, + "duration_std_ms": 19.25, + "throughput_avg_mbps": 8686.92, + "throughput_min_mbps": 8277.13, + "throughput_max_mbps": 8981.35, + "ops_per_sec_avg": 620.49, + "latency_per_key_ms": 1.612 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.97, + "duration_min_ms": 10.27, + "duration_max_ms": 11.77, + "duration_p50_ms": 10.97, + "duration_p99_ms": 11.77, + "duration_std_ms": 0.45, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46740.3, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 694.83, + "duration_min_ms": 680.3, + "duration_max_ms": 732.75, + "duration_p50_ms": 690.34, + "duration_p99_ms": 732.75, + "duration_std_ms": 12.12, + "throughput_avg_mbps": 10319.09, + "throughput_min_mbps": 9782.3, + "throughput_max_mbps": 10536.56, + "ops_per_sec_avg": 737.08, + "latency_per_key_ms": 1.357 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.cpu new file mode 100644 index 0000000..1a39d0f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 53.67037773132324, "user_s": 157.477861, "sys_s": 64.599148, "max_rss_kb": 15054684} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.json new file mode 100644 index 0000000..40fa79d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d2_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 826.49, + "duration_min_ms": 785.16, + "duration_max_ms": 891.33, + "duration_p50_ms": 798.1, + "duration_p99_ms": 891.33, + "duration_std_ms": 37.59, + "throughput_avg_mbps": 8689.98, + "throughput_min_mbps": 8041.94, + "throughput_max_mbps": 9129.31, + "ops_per_sec_avg": 620.71, + "latency_per_key_ms": 1.614 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.45, + "duration_min_ms": 9.84, + "duration_max_ms": 11.43, + "duration_p50_ms": 10.38, + "duration_p99_ms": 11.43, + "duration_std_ms": 0.36, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49031.95, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 679.94, + "duration_min_ms": 667.4, + "duration_max_ms": 726.14, + "duration_p50_ms": 675.05, + "duration_p99_ms": 726.14, + "duration_std_ms": 14.12, + "throughput_avg_mbps": 10546.26, + "throughput_min_mbps": 9871.44, + "throughput_max_mbps": 10740.23, + "ops_per_sec_avg": 753.3, + "latency_per_key_ms": 1.328 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.cpu new file mode 100644 index 0000000..aa41112 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 57.84310293197632, "user_s": 295.340577, "sys_s": 98.712129, "max_rss_kb": 15060028} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.json new file mode 100644 index 0000000..00dee67 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 460.54, + "duration_min_ms": 420.85, + "duration_max_ms": 564.19, + "duration_p50_ms": 456.29, + "duration_p99_ms": 564.19, + "duration_std_ms": 26.85, + "throughput_avg_mbps": 15612.83, + "throughput_min_mbps": 12704.87, + "throughput_max_mbps": 17032.06, + "ops_per_sec_avg": 1115.2, + "latency_per_key_ms": 0.899 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.03, + "duration_min_ms": 10.45, + "duration_max_ms": 11.8, + "duration_p50_ms": 11.03, + "duration_p99_ms": 11.8, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46443.56, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 348.13, + "duration_min_ms": 334.3, + "duration_max_ms": 372.05, + "duration_p50_ms": 346.96, + "duration_p99_ms": 372.05, + "duration_std_ms": 7.05, + "throughput_avg_mbps": 20598.29, + "throughput_min_mbps": 19266.16, + "throughput_max_mbps": 21442.07, + "ops_per_sec_avg": 1471.31, + "latency_per_key_ms": 0.68 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.cpu new file mode 100644 index 0000000..50d535a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 57.367204904556274, "user_s": 298.867607, "sys_s": 103.746883, "max_rss_kb": 15057968} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.json new file mode 100644 index 0000000..b822dbf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 451.13, + "duration_min_ms": 412.11, + "duration_max_ms": 519.47, + "duration_p50_ms": 447.19, + "duration_p99_ms": 519.47, + "duration_std_ms": 19.98, + "throughput_avg_mbps": 15918.24, + "throughput_min_mbps": 13798.73, + "throughput_max_mbps": 17393.32, + "ops_per_sec_avg": 1137.02, + "latency_per_key_ms": 0.881 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.69, + "duration_min_ms": 10.15, + "duration_max_ms": 11.58, + "duration_p50_ms": 10.52, + "duration_p99_ms": 11.58, + "duration_std_ms": 0.44, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47992.01, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 346.86, + "duration_min_ms": 334.38, + "duration_max_ms": 360.64, + "duration_p50_ms": 346.58, + "duration_p99_ms": 360.64, + "duration_std_ms": 4.71, + "throughput_avg_mbps": 20668.98, + "throughput_min_mbps": 19875.85, + "throughput_max_mbps": 21436.38, + "ops_per_sec_avg": 1476.36, + "latency_per_key_ms": 0.677 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.cpu new file mode 100644 index 0000000..11abc05 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.99170398712158, "user_s": 297.305753, "sys_s": 101.431185, "max_rss_kb": 15056952} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.json new file mode 100644 index 0000000..c7892a3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_14mib/rust_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 449.35, + "duration_min_ms": 424.33, + "duration_max_ms": 527.56, + "duration_p50_ms": 444.88, + "duration_p99_ms": 527.56, + "duration_std_ms": 19.99, + "throughput_avg_mbps": 15980.63, + "throughput_min_mbps": 13587.14, + "throughput_max_mbps": 16892.39, + "ops_per_sec_avg": 1141.47, + "latency_per_key_ms": 0.878 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.4, + "duration_min_ms": 9.53, + "duration_max_ms": 11.49, + "duration_p50_ms": 10.37, + "duration_p99_ms": 11.49, + "duration_std_ms": 0.44, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49299.07, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 342.44, + "duration_min_ms": 331.37, + "duration_max_ms": 366.6, + "duration_p50_ms": 341.35, + "duration_p99_ms": 366.6, + "duration_std_ms": 6.95, + "throughput_avg_mbps": 20940.56, + "throughput_min_mbps": 19552.75, + "throughput_max_mbps": 21631.28, + "ops_per_sec_avg": 1495.75, + "latency_per_key_ms": 0.669 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.cpu new file mode 100644 index 0000000..f0eae94 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.24386548995972, "user_s": 100.349987, "sys_s": 51.451234, "max_rss_kb": 17148388} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.json new file mode 100644 index 0000000..37ecd5a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1666.8, + "duration_min_ms": 1631.51, + "duration_max_ms": 1689.33, + "duration_p50_ms": 1669.13, + "duration_p99_ms": 1689.33, + "duration_std_ms": 13.78, + "throughput_avg_mbps": 4915.12, + "throughput_min_mbps": 4849.25, + "throughput_max_mbps": 5021.12, + "ops_per_sec_avg": 307.2, + "latency_per_key_ms": 3.255 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 10.16, + "duration_min_ms": 8.33, + "duration_max_ms": 10.77, + "duration_p50_ms": 10.29, + "duration_p99_ms": 10.77, + "duration_std_ms": 0.56, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 50552.64, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1369.85, + "duration_min_ms": 1329.29, + "duration_max_ms": 1494.11, + "duration_p50_ms": 1356.57, + "duration_p99_ms": 1494.11, + "duration_std_ms": 45.01, + "throughput_avg_mbps": 5985.92, + "throughput_min_mbps": 5482.87, + "throughput_max_mbps": 6162.68, + "ops_per_sec_avg": 374.12, + "latency_per_key_ms": 2.675 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.cpu new file mode 100644 index 0000000..29f5cc6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.101338624954224, "user_s": 98.617541, "sys_s": 49.831349, "max_rss_kb": 17147992} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.json new file mode 100644 index 0000000..be00339 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1641.96, + "duration_min_ms": 1624.97, + "duration_max_ms": 1651.47, + "duration_p50_ms": 1644.66, + "duration_p99_ms": 1651.47, + "duration_std_ms": 9.03, + "throughput_avg_mbps": 4989.3, + "throughput_min_mbps": 4960.42, + "throughput_max_mbps": 5041.31, + "ops_per_sec_avg": 311.83, + "latency_per_key_ms": 3.207 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 10.78, + "duration_min_ms": 10.09, + "duration_max_ms": 11.4, + "duration_p50_ms": 10.99, + "duration_p99_ms": 11.4, + "duration_std_ms": 0.51, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47575.8, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1394.14, + "duration_min_ms": 1362.08, + "duration_max_ms": 1461.25, + "duration_p50_ms": 1385.85, + "duration_p99_ms": 1461.25, + "duration_std_ms": 25.28, + "throughput_avg_mbps": 5877.79, + "throughput_min_mbps": 5606.16, + "throughput_max_mbps": 6014.32, + "ops_per_sec_avg": 367.36, + "latency_per_key_ms": 2.723 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.cpu new file mode 100644 index 0000000..a1c8365 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 56.53863191604614, "user_s": 101.44392, "sys_s": 49.539539, "max_rss_kb": 17144416} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.json new file mode 100644 index 0000000..81f3528 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d1_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 14, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1643.54, + "duration_min_ms": 1615.8, + "duration_max_ms": 1675.56, + "duration_p50_ms": 1643.44, + "duration_p99_ms": 1675.56, + "duration_std_ms": 12.19, + "throughput_avg_mbps": 4984.63, + "throughput_min_mbps": 4889.12, + "throughput_max_mbps": 5069.94, + "ops_per_sec_avg": 311.54, + "latency_per_key_ms": 3.21 + }, + "op_1": { + "operation": "Lookup", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 0, + "duration_avg_ms": 9.88, + "duration_min_ms": 8.89, + "duration_max_ms": 10.72, + "duration_p50_ms": 9.83, + "duration_p99_ms": 10.72, + "duration_std_ms": 0.62, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 52018.78, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 14, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 7168, + "total_success": 7168, + "duration_avg_ms": 1404.13, + "duration_min_ms": 1341.67, + "duration_max_ms": 1572.78, + "duration_p50_ms": 1376.68, + "duration_p99_ms": 1572.78, + "duration_std_ms": 65.03, + "throughput_avg_mbps": 5845.14, + "throughput_min_mbps": 5208.6, + "throughput_max_mbps": 6105.85, + "ops_per_sec_avg": 365.32, + "latency_per_key_ms": 2.742 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.cpu new file mode 100644 index 0000000..0a6de10 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 55.98424696922302, "user_s": 177.737351, "sys_s": 73.294722, "max_rss_kb": 17146764} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.json new file mode 100644 index 0000000..d3280be --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 878.88, + "duration_min_ms": 848.86, + "duration_max_ms": 1108.92, + "duration_p50_ms": 866.96, + "duration_p99_ms": 1108.92, + "duration_std_ms": 48.39, + "throughput_avg_mbps": 9343.43, + "throughput_min_mbps": 7387.36, + "throughput_max_mbps": 9650.57, + "ops_per_sec_avg": 583.96, + "latency_per_key_ms": 1.717 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 9.91, + "duration_min_ms": 7.6, + "duration_max_ms": 11.39, + "duration_p50_ms": 9.45, + "duration_p99_ms": 11.39, + "duration_std_ms": 0.99, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 52200.38, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 693.12, + "duration_min_ms": 673.99, + "duration_max_ms": 724.37, + "duration_p50_ms": 691.28, + "duration_p99_ms": 724.37, + "duration_std_ms": 11.42, + "throughput_avg_mbps": 11822.03, + "throughput_min_mbps": 11309.14, + "throughput_max_mbps": 12154.41, + "ops_per_sec_avg": 738.88, + "latency_per_key_ms": 1.354 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.cpu new file mode 100644 index 0000000..e538a9a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 55.74272131919861, "user_s": 176.806747, "sys_s": 71.605984, "max_rss_kb": 17146368} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.json new file mode 100644 index 0000000..276e2e2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 867.04, + "duration_min_ms": 825.88, + "duration_max_ms": 934.12, + "duration_p50_ms": 866.88, + "duration_p99_ms": 934.12, + "duration_std_ms": 32.28, + "throughput_avg_mbps": 9460.65, + "throughput_min_mbps": 8769.74, + "throughput_max_mbps": 9919.1, + "ops_per_sec_avg": 591.29, + "latency_per_key_ms": 1.693 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.68, + "duration_min_ms": 10.14, + "duration_max_ms": 11.85, + "duration_p50_ms": 10.38, + "duration_p99_ms": 11.85, + "duration_std_ms": 0.55, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48063.65, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 694.23, + "duration_min_ms": 667.67, + "duration_max_ms": 735.65, + "duration_p50_ms": 690.33, + "duration_p99_ms": 735.65, + "duration_std_ms": 14.0, + "throughput_avg_mbps": 11804.71, + "throughput_min_mbps": 11135.72, + "throughput_max_mbps": 12269.47, + "ops_per_sec_avg": 737.79, + "latency_per_key_ms": 1.356 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.cpu new file mode 100644 index 0000000..57f58a1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 55.51257658004761, "user_s": 177.4961, "sys_s": 71.352732, "max_rss_kb": 17147460} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.json new file mode 100644 index 0000000..e193a36 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d2_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 28, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 863.28, + "duration_min_ms": 834.6, + "duration_max_ms": 932.79, + "duration_p50_ms": 851.33, + "duration_p99_ms": 932.79, + "duration_std_ms": 26.08, + "throughput_avg_mbps": 9497.6, + "throughput_min_mbps": 8782.29, + "throughput_max_mbps": 9815.51, + "ops_per_sec_avg": 593.6, + "latency_per_key_ms": 1.686 + }, + "op_1": { + "operation": "Lookup", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 0, + "duration_avg_ms": 10.38, + "duration_min_ms": 10.05, + "duration_max_ms": 10.81, + "duration_p50_ms": 10.31, + "duration_p99_ms": 10.81, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49347.16, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 28, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 14336, + "total_success": 14336, + "duration_avg_ms": 691.06, + "duration_min_ms": 674.59, + "duration_max_ms": 709.09, + "duration_p50_ms": 691.68, + "duration_p99_ms": 709.09, + "duration_std_ms": 9.6, + "throughput_avg_mbps": 11856.42, + "throughput_min_mbps": 11552.76, + "throughput_max_mbps": 12143.64, + "ops_per_sec_avg": 741.03, + "latency_per_key_ms": 1.35 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.cpu new file mode 100644 index 0000000..335c139 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 58.76039242744446, "user_s": 334.956348, "sys_s": 120.578718, "max_rss_kb": 17149788} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.json new file mode 100644 index 0000000..37119f4 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 463.48, + "duration_min_ms": 438.06, + "duration_max_ms": 552.73, + "duration_p50_ms": 459.22, + "duration_p99_ms": 552.73, + "duration_std_ms": 20.99, + "throughput_avg_mbps": 17708.03, + "throughput_min_mbps": 14820.98, + "throughput_max_mbps": 18700.57, + "ops_per_sec_avg": 1106.75, + "latency_per_key_ms": 0.905 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.68, + "duration_min_ms": 9.93, + "duration_max_ms": 11.4, + "duration_p50_ms": 10.8, + "duration_p99_ms": 11.4, + "duration_std_ms": 0.49, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48042.96, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 345.78, + "duration_min_ms": 333.92, + "duration_max_ms": 357.43, + "duration_p50_ms": 345.06, + "duration_p99_ms": 357.43, + "duration_std_ms": 6.02, + "throughput_avg_mbps": 23698.49, + "throughput_min_mbps": 22919.49, + "throughput_max_mbps": 24532.48, + "ops_per_sec_avg": 1481.16, + "latency_per_key_ms": 0.675 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.cpu new file mode 100644 index 0000000..3cd6c3c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 58.53435683250427, "user_s": 334.007631, "sys_s": 118.320557, "max_rss_kb": 17153344} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.json new file mode 100644 index 0000000..28a6d75 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 459.67, + "duration_min_ms": 431.83, + "duration_max_ms": 571.49, + "duration_p50_ms": 450.63, + "duration_p99_ms": 571.49, + "duration_std_ms": 24.66, + "throughput_avg_mbps": 17867.47, + "throughput_min_mbps": 14334.58, + "throughput_max_mbps": 18970.49, + "ops_per_sec_avg": 1116.72, + "latency_per_key_ms": 0.898 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.03, + "duration_min_ms": 10.15, + "duration_max_ms": 12.19, + "duration_p50_ms": 11.02, + "duration_p99_ms": 12.19, + "duration_std_ms": 0.55, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46533.87, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 345.9, + "duration_min_ms": 335.02, + "duration_max_ms": 381.59, + "duration_p50_ms": 344.3, + "duration_p99_ms": 381.59, + "duration_std_ms": 8.35, + "throughput_avg_mbps": 23696.05, + "throughput_min_mbps": 21468.3, + "throughput_max_mbps": 24452.42, + "ops_per_sec_avg": 1481.0, + "latency_per_key_ms": 0.676 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.cpu new file mode 100644 index 0000000..d3bec02 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 58.268837213516235, "user_s": 334.842844, "sys_s": 122.672325, "max_rss_kb": 17151456} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.json new file mode 100644 index 0000000..ccd29f8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/scale_16mib/rust_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 16384, + "data_per_round_mb": 8192.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 455.79, + "duration_min_ms": 422.48, + "duration_max_ms": 515.63, + "duration_p50_ms": 449.33, + "duration_p99_ms": 515.63, + "duration_std_ms": 21.38, + "throughput_avg_mbps": 18011.05, + "throughput_min_mbps": 15887.46, + "throughput_max_mbps": 19390.14, + "ops_per_sec_avg": 1125.69, + "latency_per_key_ms": 0.89 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.6, + "duration_min_ms": 10.31, + "duration_max_ms": 12.92, + "duration_p50_ms": 11.5, + "duration_p99_ms": 12.92, + "duration_std_ms": 0.7, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 44296.32, + "latency_per_key_ms": 0.023 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 344.93, + "duration_min_ms": 334.88, + "duration_max_ms": 359.96, + "duration_p50_ms": 343.91, + "duration_p99_ms": 359.96, + "duration_std_ms": 5.28, + "throughput_avg_mbps": 23755.23, + "throughput_min_mbps": 22757.77, + "throughput_max_mbps": 24462.72, + "ops_per_sec_avg": 1484.7, + "latency_per_key_ms": 0.674 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_after.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_after.txt new file mode 100644 index 0000000..573541a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_after.txt @@ -0,0 +1 @@ +0 diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_before.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_before.txt new file mode 100644 index 0000000..573541a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/dmesg_before.txt @@ -0,0 +1 @@ +0 diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/fill.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/fill.json new file mode 100644 index 0000000..4b37d35 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/fill.json @@ -0,0 +1 @@ +{"ok": 8192, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 6.04, "mb_s": 19897, "batch_ms_p50": 45.7, "batch_ms_p99": 56.2, "wrong_ids": [], "errors": {}, "mode": "store", "workers": 32, "in_flight": 64, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 120259084288, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/iostat.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/iostat.txt new file mode 100644 index 0000000..13b8f58 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/iostat.txt @@ -0,0 +1,312 @@ +Linux 6.8.0-147-generic (node) 11/04/2026 _x86_64_ (96 CPU) + +avg-cpu: %user %nice %system %iowait %steal %idle + 2.12 0.00 1.26 7.58 0.00 89.04 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 9512.01 1183.49 11.86 0.12 21.36 127.41 8728.91 1083.64 86.87 0.99 27.32 127.12 15.76 56757.88 0.00 0.00 223.41 3688362.31 0.00 0.00 67.00 46.55 +nvme2n1 6929.86 861.52 10.83 0.16 16.35 127.30 6192.42 768.40 76.92 1.23 22.98 127.07 15.76 56757.88 0.00 0.00 233.11 3688362.31 0.00 0.00 259.26 33.93 +nvme3n1 5368.67 668.47 7.11 0.13 4.51 127.50 4672.44 581.02 75.83 1.60 6.65 127.34 14.81 54823.02 0.00 0.00 230.15 3789925.85 0.00 0.00 58.69 26.65 +nvme4n1 4856.97 604.48 7.42 0.15 4.22 127.44 4166.78 517.83 66.37 1.57 5.70 127.26 14.81 54823.02 0.00 0.00 230.69 3789925.85 0.00 0.00 47.64 25.12 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 2.05 0.00 3.51 21.88 0.00 72.56 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 39557.12 4921.42 328.22 0.82 2.97 127.40 3774.67 471.83 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 122.42 94.86 +nvme2n1 39552.05 4920.48 329.17 0.83 3.03 127.39 3774.40 471.80 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.52 94.59 +nvme3n1 39549.45 4920.39 328.58 0.82 3.19 127.40 3773.60 471.70 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.25 94.84 +nvme4n1 39551.80 4920.74 329.22 0.83 3.18 127.40 3774.93 471.87 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.04 94.85 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.57 21.65 0.00 72.82 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40350.22 5019.90 243.60 0.60 2.98 127.39 3765.87 470.73 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.15 95.43 +nvme2n1 40353.80 5020.43 246.35 0.61 3.02 127.40 3769.33 471.17 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 126.83 94.30 +nvme3n1 40357.30 5021.00 246.62 0.61 3.19 127.40 3765.07 470.63 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.60 94.33 +nvme4n1 40356.53 5021.19 246.90 0.61 3.19 127.41 3767.47 470.93 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.59 94.40 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.60 20.93 0.00 73.49 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40574.90 5049.73 292.32 0.72 2.97 127.44 3770.67 471.33 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.49 94.57 +nvme2n1 40568.82 5048.45 291.32 0.71 3.03 127.43 3770.13 471.27 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.05 94.47 +nvme3n1 40568.33 5048.38 292.00 0.71 3.18 127.43 3771.73 471.47 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.11 94.76 +nvme4n1 40570.23 5048.94 293.10 0.72 3.19 127.44 3770.13 471.27 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.31 94.66 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.44 21.41 0.00 73.19 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40418.00 5029.71 292.08 0.72 2.95 127.43 3770.67 471.33 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.05 94.08 +nvme2n1 40432.43 5031.85 290.92 0.71 3.10 127.44 3771.73 471.47 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.53 94.24 +nvme3n1 40431.65 5031.82 290.82 0.71 3.26 127.44 3769.33 471.17 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.79 94.28 +nvme4n1 40426.38 5030.79 291.17 0.72 3.19 127.43 3770.93 471.37 0.00 0.00 1.37 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.27 94.31 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.62 20.85 0.00 73.54 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40416.47 5026.65 278.92 0.69 2.95 127.36 3772.53 471.57 0.00 0.00 1.28 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.91 94.19 +nvme2n1 40407.55 5025.12 278.32 0.68 3.04 127.35 3770.67 471.33 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.71 94.24 +nvme3n1 40404.25 5024.69 280.53 0.69 3.22 127.34 3769.07 471.13 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.24 94.37 +nvme4n1 40417.35 5026.06 279.30 0.69 3.15 127.34 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.13 94.44 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.61 20.99 0.00 73.42 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40129.42 4989.90 267.27 0.66 2.91 127.33 3771.20 471.40 0.00 0.00 1.27 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 121.65 93.93 +nvme2n1 40137.68 4990.95 267.28 0.66 3.09 127.33 3769.33 471.17 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.10 93.70 +nvme3n1 40143.18 4991.50 267.65 0.66 3.20 127.33 3770.93 471.37 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.57 93.86 +nvme4n1 40134.78 4990.52 267.88 0.66 3.11 127.33 3771.20 471.40 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.88 94.05 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.51 21.28 0.00 73.21 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40733.10 5066.28 293.17 0.71 2.96 127.36 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.51 94.63 +nvme2n1 40721.20 5064.93 294.73 0.72 3.08 127.37 3764.80 470.60 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.33 94.77 +nvme3n1 40719.50 5064.48 291.48 0.71 3.19 127.36 3766.93 470.87 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.83 94.90 +nvme4n1 40725.40 5065.21 291.42 0.71 3.15 127.36 3765.60 470.70 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.04 94.82 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.49 20.87 0.00 73.65 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40528.27 5042.25 298.43 0.73 2.93 127.40 3769.07 471.13 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 123.72 94.37 +nvme2n1 40542.52 5043.74 294.88 0.72 3.14 127.39 3772.80 471.60 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.20 94.46 +nvme3n1 40541.00 5043.73 300.20 0.74 3.19 127.40 3770.93 471.37 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.45 94.59 +nvme4n1 40531.60 5042.61 297.08 0.73 3.17 127.40 3769.87 471.23 0.00 0.00 1.35 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.53 94.50 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.61 20.90 0.00 73.50 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40404.63 5026.39 285.93 0.70 2.96 127.39 3770.67 471.33 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.69 94.34 +nvme2n1 40399.82 5025.47 287.62 0.71 3.16 127.38 3769.07 471.13 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.74 94.28 +nvme3n1 40395.88 5025.03 285.55 0.70 3.18 127.38 3771.20 471.40 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.43 94.43 +nvme4n1 40410.25 5026.74 286.38 0.70 3.09 127.38 3771.73 471.47 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.01 94.41 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.40 21.53 0.00 73.11 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40715.92 5065.38 290.15 0.71 2.93 127.39 3771.47 471.43 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 124.05 94.46 +nvme2n1 40726.32 5066.19 287.48 0.70 3.14 127.38 3766.67 470.83 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.70 94.52 +nvme3n1 40728.75 5066.53 288.82 0.70 3.22 127.38 3772.53 471.57 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.32 94.83 +nvme4n1 40715.42 5064.64 285.20 0.70 3.12 127.38 3772.00 471.50 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.97 94.64 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.54 20.93 0.00 73.56 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40395.62 5028.36 291.68 0.72 3.00 127.47 3765.87 470.73 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 126.31 94.26 +nvme2n1 40392.53 5028.01 292.12 0.72 3.16 127.47 3766.40 470.80 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.77 94.43 +nvme3n1 40390.40 5027.63 292.62 0.72 3.23 127.46 3767.20 470.90 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.37 94.35 +nvme4n1 40401.40 5029.06 288.83 0.71 3.12 127.46 3768.27 471.03 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.94 94.41 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.48 21.71 0.00 72.85 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40610.15 5050.20 304.47 0.74 3.11 127.34 3769.87 471.23 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.42 94.59 +nvme2n1 40616.10 5050.43 304.22 0.74 3.22 127.33 3770.93 471.37 0.00 0.00 1.35 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.99 94.66 +nvme3n1 40621.15 5051.06 305.40 0.75 3.18 127.33 3770.13 471.27 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.15 94.54 +nvme4n1 40608.08 5049.29 301.28 0.74 3.12 127.33 3771.73 471.47 0.00 0.00 1.36 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.89 94.50 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 2.01 0.01 3.53 21.86 0.00 72.58 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40190.42 4998.49 294.90 0.73 3.15 127.36 3771.47 471.43 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.56 93.86 +nvme2n1 40188.45 4998.40 295.87 0.73 3.21 127.36 3772.00 471.50 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.88 94.03 +nvme3n1 40187.35 4998.20 296.25 0.73 3.17 127.36 3769.07 471.13 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.40 94.03 +nvme4n1 40194.07 4999.36 295.30 0.73 3.13 127.37 3770.13 471.27 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.76 93.96 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.41 21.31 0.00 73.31 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40506.32 5037.43 297.80 0.73 3.10 127.35 3769.87 471.23 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.69 94.38 +nvme2n1 40510.02 5038.02 296.88 0.73 3.24 127.35 3770.93 471.37 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.46 94.38 +nvme3n1 40511.03 5037.79 297.67 0.73 3.21 127.34 3770.93 471.37 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.03 94.40 +nvme4n1 40499.85 5036.75 298.20 0.73 3.07 127.35 3770.93 471.37 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.20 94.31 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.59 20.95 0.00 73.49 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40201.83 5002.27 315.90 0.78 3.15 127.42 3771.18 471.40 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.47 93.96 +nvme2n1 40195.47 5001.29 314.37 0.78 3.23 127.41 3770.07 471.26 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.86 95.33 +nvme3n1 40198.77 5001.69 317.82 0.78 3.14 127.41 3770.77 471.35 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.94 94.05 +nvme4n1 40206.45 5002.90 319.17 0.79 3.04 127.42 3769.33 471.17 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.20 95.08 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.63 20.97 0.00 73.43 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40344.38 5015.44 312.13 0.77 3.11 127.30 3767.75 470.97 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.63 94.14 +nvme2n1 40352.53 5016.22 312.82 0.77 3.26 127.29 3769.93 471.24 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.78 94.17 +nvme3n1 40349.45 5015.92 311.75 0.77 3.14 127.30 3766.30 470.79 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.68 94.18 +nvme4n1 40337.95 5014.64 314.62 0.77 3.06 127.30 3765.07 470.63 0.00 0.00 1.36 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.43 94.18 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.69 20.74 0.00 73.58 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40530.90 5038.33 308.97 0.76 3.06 127.29 3768.27 471.03 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.78 94.47 +nvme2n1 40533.48 5038.62 306.05 0.75 3.22 127.29 3770.13 471.27 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.44 94.71 +nvme3n1 40535.68 5038.69 310.08 0.76 3.14 127.29 3770.93 471.37 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.22 94.69 +nvme4n1 40543.13 5040.14 310.82 0.76 3.12 127.30 3773.33 471.67 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.33 94.63 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.46 21.13 0.00 73.43 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40632.52 5048.29 309.30 0.76 3.10 127.22 3769.60 471.20 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.14 94.43 +nvme2n1 40628.48 5047.95 308.90 0.75 3.24 127.23 3771.20 471.40 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.48 94.53 +nvme3n1 40624.88 5047.57 311.77 0.76 3.15 127.23 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.99 94.73 +nvme4n1 40621.80 5046.98 308.77 0.75 3.08 127.22 3771.47 471.43 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.20 94.52 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.61 21.02 0.00 73.38 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40515.62 5038.39 315.10 0.77 3.15 127.34 3768.67 471.08 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.56 94.47 +nvme2n1 40521.12 5038.86 314.48 0.77 3.23 127.34 3769.53 471.19 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.83 94.49 +nvme3n1 40518.92 5038.78 314.90 0.77 3.20 127.34 3768.15 471.02 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.60 94.38 +nvme4n1 40523.32 5039.08 313.55 0.77 2.99 127.33 3766.82 470.85 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 126.32 94.46 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.65 21.46 0.00 72.93 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40324.32 5015.62 319.38 0.79 3.09 127.37 3771.07 471.38 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.39 94.28 +nvme2n1 40311.58 5013.68 317.40 0.78 3.21 127.36 3768.87 471.11 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.45 94.37 +nvme3n1 40311.83 5013.79 316.12 0.78 3.19 127.36 3768.65 471.08 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.35 94.35 +nvme4n1 40317.65 5014.64 319.53 0.79 3.13 127.36 3768.65 471.08 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.04 94.23 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.47 20.80 0.00 73.74 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40622.58 5052.77 335.25 0.82 3.07 127.37 3771.20 471.40 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.48 94.71 +nvme2n1 40644.38 5055.34 335.58 0.82 3.25 127.36 3769.60 471.20 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.75 94.80 +nvme3n1 40643.58 5055.04 338.58 0.83 3.18 127.36 3771.47 471.43 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.18 94.84 +nvme4n1 40632.68 5053.73 336.92 0.82 3.07 127.36 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.80 94.69 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.44 21.33 0.00 73.25 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40535.85 5039.34 321.80 0.79 3.05 127.30 3770.93 471.37 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 128.44 94.28 +nvme2n1 40521.27 5037.29 321.43 0.79 3.19 127.30 3771.47 471.43 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.09 94.46 +nvme3n1 40522.17 5037.48 324.67 0.79 3.22 127.30 3769.87 471.23 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.43 94.48 +nvme4n1 40531.83 5038.70 319.67 0.78 3.12 127.30 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.43 94.43 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.62 21.33 0.00 73.10 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40263.82 5008.49 330.47 0.81 3.13 127.38 3769.50 471.19 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.07 94.00 +nvme2n1 40278.83 5010.18 327.18 0.81 3.18 127.37 3767.97 471.00 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.89 94.30 +nvme3n1 40280.33 5010.44 331.60 0.82 3.17 127.37 3768.13 471.02 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.61 95.46 +nvme4n1 40268.72 5008.92 326.78 0.80 3.10 127.37 3770.00 471.25 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.92 94.15 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.56 20.82 0.00 73.63 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40427.42 5028.87 339.77 0.83 3.15 127.38 3768.63 471.08 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.13 94.38 +nvme2n1 40412.63 5027.13 342.00 0.84 3.12 127.38 3768.57 471.07 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.03 94.59 +nvme3n1 40414.02 5026.95 340.05 0.83 3.16 127.37 3769.20 471.15 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.60 94.51 +nvme4n1 40418.55 5028.15 343.03 0.84 3.13 127.39 3768.40 471.05 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.50 94.57 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.55 21.17 0.00 73.32 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40437.48 5027.01 331.10 0.81 3.11 127.30 3769.60 471.20 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.51 94.31 +nvme2n1 40449.32 5028.52 331.53 0.81 3.14 127.30 3770.67 471.33 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.17 94.41 +nvme3n1 40447.53 5028.29 332.25 0.81 3.14 127.30 3769.87 471.23 0.00 0.00 1.30 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.91 94.52 +nvme4n1 40435.05 5026.78 328.37 0.81 3.13 127.30 3772.53 471.57 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.76 94.49 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.99 0.00 3.65 20.72 0.00 73.64 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40476.98 5031.30 336.03 0.82 3.08 127.28 3769.75 471.22 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.58 94.48 +nvme2n1 40470.60 5029.91 334.02 0.82 3.16 127.27 3770.37 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.72 94.60 +nvme3n1 40469.12 5030.05 335.47 0.82 3.18 127.28 3770.65 471.33 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.91 94.74 +nvme4n1 40482.78 5031.82 337.35 0.83 3.14 127.28 3770.40 471.30 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.25 94.70 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.53 21.10 0.00 73.39 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40661.58 5055.29 323.92 0.79 3.08 127.31 3767.32 470.91 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.20 94.68 +nvme2n1 40665.23 5055.53 323.43 0.79 3.17 127.30 3766.70 470.84 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 133.96 94.64 +nvme3n1 40669.23 5055.96 320.95 0.78 3.24 127.30 3769.08 471.13 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 136.80 94.77 +nvme4n1 40653.70 5054.26 322.23 0.79 3.09 127.31 3766.13 470.77 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.41 94.65 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.97 0.00 3.65 21.04 0.00 73.34 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40354.88 5018.89 342.17 0.84 2.99 127.35 3771.73 471.47 0.00 0.00 1.29 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 125.48 94.40 +nvme2n1 40351.43 5018.63 343.43 0.84 3.23 127.36 3773.33 471.67 0.00 0.00 1.31 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.14 94.55 +nvme3n1 40354.28 5018.65 343.87 0.84 3.20 127.35 3768.53 471.07 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.13 94.56 +nvme4n1 40358.17 5019.70 346.18 0.85 3.14 127.36 3769.07 471.13 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 131.55 94.42 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.96 0.00 3.67 21.32 0.00 73.05 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40544.65 5039.30 320.97 0.79 3.09 127.27 3769.33 471.17 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 130.43 94.62 +nvme2n1 40543.72 5039.82 325.42 0.80 3.23 127.29 3771.73 471.47 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.79 94.69 +nvme3n1 40551.00 5040.06 321.15 0.79 3.22 127.27 3769.33 471.17 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 135.42 94.64 +nvme4n1 40536.53 5038.81 324.65 0.79 3.02 127.29 3772.27 471.53 0.00 0.00 1.33 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 127.30 94.66 + + +avg-cpu: %user %nice %system %iowait %steal %idle + 1.98 0.00 3.63 20.92 0.00 73.48 + +Device r/s rMB/s rrqm/s %rrqm r_await rareq-sz w/s wMB/s wrqm/s %wrqm w_await wareq-sz d/s dMB/s drqm/s %drqm d_await dareq-sz f/s f_await aqu-sz %util +nvme1n1 40165.42 4994.60 327.93 0.81 3.10 127.34 3771.20 471.40 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.64 93.91 +nvme2n1 40163.33 4994.23 327.80 0.81 3.21 127.33 3768.80 471.10 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 134.00 94.02 +nvme3n1 40157.88 4993.80 326.88 0.81 3.17 127.34 3771.73 471.47 0.00 0.00 1.32 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 132.38 94.11 +nvme4n1 40164.57 4995.04 329.12 0.81 3.10 127.35 3770.93 471.37 0.00 0.00 1.34 128.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 129.40 93.98 + + diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/load.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/load.jsonl new file mode 100644 index 0000000..f399a60 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/load.jsonl @@ -0,0 +1,31 @@ +{"ok": 84585, "miss": 15, "wrong": 0, "verified": 10565, "batches_failed": 15, "hang": false, "seconds": 59.49, "mb_s": 20874, "batch_ms_p50": 43.0, "batch_ms_p99": 58.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000048a": 1, "load missed for m@00000000@0@0000077f": 1, "load missed for m@00000000@0@0000028b": 1, "load missed for m@00000000@0@000004b3": 1}, "t": 1, "mode": "load", "utc": "08:44:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 1241713213440, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86321, "miss": 7, "wrong": 0, "verified": 10784, "batches_failed": 7, "hang": false, "seconds": 59.48, "mb_s": 21304, "batch_ms_p50": 41.9, "batch_ms_p99": 57.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000c79": 1, "load missed for m@00000000@0@0000065d": 1, "load missed for m@00000000@0@0000009a": 1, "load missed for m@00000000@0@00000403": 1}, "t": 2, "mode": "load", "utc": "08:45:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 2508911017984, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86806, "miss": 10, "wrong": 0, "verified": 10846, "batches_failed": 10, "hang": false, "seconds": 59.49, "mb_s": 21419, "batch_ms_p50": 41.7, "batch_ms_p99": 57.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000009f8": 1, "load missed for m@00000000@0@00000b9a": 1, "load missed for m@00000000@0@000012ae": 1, "load missed for m@00000000@0@000000b5": 1}, "t": 3, "mode": "load", "utc": "08:46:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 3783228653568, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86502, "miss": 18, "wrong": 0, "verified": 10804, "batches_failed": 18, "hang": false, "seconds": 59.47, "mb_s": 21351, "batch_ms_p50": 42.0, "batch_ms_p99": 57.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001f2c": 1, "load missed for m@00000000@0@0000171d": 1, "load missed for m@00000000@0@000000b9": 1, "load missed for m@00000000@0@00001ada": 1}, "t": 4, "mode": "load", "utc": "08:47:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 5053083549696, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86443, "miss": 21, "wrong": 0, "verified": 10805, "batches_failed": 21, "hang": false, "seconds": 59.5, "mb_s": 21326, "batch_ms_p50": 41.9, "batch_ms_p99": 56.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001588": 1, "load missed for m@00000000@0@00000561": 1, "load missed for m@00000000@0@0000078d": 1, "load missed for m@00000000@0@000009a5": 1}, "t": 5, "mode": "load", "utc": "08:48:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 6322072322048, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 85867, "miss": 5, "wrong": 0, "verified": 10728, "batches_failed": 5, "hang": false, "seconds": 59.49, "mb_s": 21189, "batch_ms_p50": 42.3, "batch_ms_p99": 57.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000117e": 1, "load missed for m@00000000@0@000011f9": 1, "load missed for m@00000000@0@0000005d": 1, "load missed for m@00000000@0@000018ad": 1}, "t": 6, "mode": "load", "utc": "08:49:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 7582605377536, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 87009, "miss": 15, "wrong": 0, "verified": 10869, "batches_failed": 15, "hang": false, "seconds": 59.49, "mb_s": 21471, "batch_ms_p50": 41.7, "batch_ms_p99": 57.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000c27": 1, "load missed for m@00000000@0@0000070b": 1, "load missed for m@00000000@0@00000632": 1, "load missed for m@00000000@0@0000056a": 1}, "t": 7, "mode": "load", "utc": "08:50:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 8859903066112, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86833, "miss": 15, "wrong": 0, "verified": 10854, "batches_failed": 14, "hang": false, "seconds": 59.5, "mb_s": 21425, "batch_ms_p50": 42.0, "batch_ms_p99": 56.6, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000002f2": 1, "load missed for m@00000000@0@0000008b": 1, "load missed for m@00000000@0@000011c7": 1, "load missed for m@00000000@0@00001205": 1}, "t": 8, "mode": "load", "utc": "08:51:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 10134617063424, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86448, "miss": 16, "wrong": 0, "verified": 10806, "batches_failed": 16, "hang": false, "seconds": 59.5, "mb_s": 21330, "batch_ms_p50": 42.0, "batch_ms_p99": 57.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000000df": 1, "load missed for m@00000000@0@000005d3": 1, "load missed for m@00000000@0@0000076d": 1, "load missed for m@00000000@0@00000e7b": 1}, "t": 9, "mode": "load", "utc": "08:52:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 11403679236096, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 87125, "miss": 19, "wrong": 0, "verified": 10885, "batches_failed": 19, "hang": false, "seconds": 59.5, "mb_s": 21497, "batch_ms_p50": 41.9, "batch_ms_p99": 56.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000012c4": 1, "load missed for m@00000000@0@0000116f": 1, "load missed for m@00000000@0@00001b97": 1, "load missed for m@00000000@0@00001b46": 1}, "t": 10, "mode": "load", "utc": "08:53:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 12682679812096, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86506, "miss": 14, "wrong": 0, "verified": 10804, "batches_failed": 14, "hang": false, "seconds": 59.47, "mb_s": 21352, "batch_ms_p50": 42.0, "batch_ms_p99": 56.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001371": 1, "load missed for m@00000000@0@00001f6c": 1, "load missed for m@00000000@0@00000811": 1, "load missed for m@00000000@0@00001d81": 1}, "t": 11, "mode": "load", "utc": "08:54:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 13952593428480, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86760, "miss": 16, "wrong": 0, "verified": 10836, "batches_failed": 16, "hang": false, "seconds": 59.48, "mb_s": 21412, "batch_ms_p50": 42.0, "batch_ms_p99": 57.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000003ff": 1, "load missed for m@00000000@0@00000949": 1, "load missed for m@00000000@0@00000f48": 1, "load missed for m@00000000@0@000011c1": 1}, "t": 12, "mode": "load", "utc": "08:55:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 15226235781120, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 85971, "miss": 13, "wrong": 0, "verified": 10744, "batches_failed": 13, "hang": false, "seconds": 59.49, "mb_s": 21216, "batch_ms_p50": 42.5, "batch_ms_p99": 58.0, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000000de": 1, "load missed for m@00000000@0@000011d0": 1, "load missed for m@00000000@0@000007b5": 1, "load missed for m@00000000@0@00000e0d": 1}, "t": 13, "mode": "load", "utc": "08:56:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 16488295563264, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86699, "miss": 21, "wrong": 0, "verified": 10838, "batches_failed": 21, "hang": false, "seconds": 59.49, "mb_s": 21393, "batch_ms_p50": 42.1, "batch_ms_p99": 57.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000811": 1, "load missed for m@00000000@0@00000748": 1, "load missed for m@00000000@0@00000196": 1, "load missed for m@00000000@0@00001bcf": 1}, "t": 14, "mode": "load", "utc": "08:57:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 17761042432000, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86001, "miss": 7, "wrong": 0, "verified": 10742, "batches_failed": 7, "hang": false, "seconds": 59.48, "mb_s": 21226, "batch_ms_p50": 42.5, "batch_ms_p99": 58.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000008f": 1, "load missed for m@00000000@0@000008e7": 1, "load missed for m@00000000@0@0000070d": 1, "load missed for m@00000000@0@00001543": 1}, "t": 15, "mode": "load", "utc": "08:58:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 19023542616064, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86212, "miss": 20, "wrong": 0, "verified": 10774, "batches_failed": 20, "hang": false, "seconds": 59.5, "mb_s": 21271, "batch_ms_p50": 42.2, "batch_ms_p99": 57.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000000db": 1, "load missed for m@00000000@0@000010a9": 1, "load missed for m@00000000@0@00000d21": 1, "load missed for m@00000000@0@000016f8": 1}, "t": 16, "mode": "load", "utc": "08:59:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 20289140293632, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86573, "miss": 11, "wrong": 0, "verified": 10813, "batches_failed": 11, "hang": false, "seconds": 59.48, "mb_s": 21368, "batch_ms_p50": 42.1, "batch_ms_p99": 56.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000ed0": 1, "load missed for m@00000000@0@00000914": 1, "load missed for m@00000000@0@0000186e": 1, "load missed for m@00000000@0@0000056e": 1}, "t": 17, "mode": "load", "utc": "09:00:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 21560037474304, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86887, "miss": 9, "wrong": 0, "verified": 10855, "batches_failed": 9, "hang": false, "seconds": 59.49, "mb_s": 21439, "batch_ms_p50": 41.9, "batch_ms_p99": 56.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001ac6": 1, "load missed for m@00000000@0@00000d32": 1, "load missed for m@00000000@0@0000152c": 1, "load missed for m@00000000@0@00001b1e": 1}, "t": 18, "mode": "load", "utc": "09:01:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 22835544195072, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86693, "miss": 19, "wrong": 0, "verified": 10831, "batches_failed": 19, "hang": false, "seconds": 59.48, "mb_s": 21396, "batch_ms_p50": 41.9, "batch_ms_p99": 57.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000019d7": 1, "load missed for m@00000000@0@000014b8": 1, "load missed for m@00000000@0@00001e2d": 1, "load missed for m@00000000@0@00000adf": 1}, "t": 19, "mode": "load", "utc": "09:02:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 24108202983424, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86187, "miss": 13, "wrong": 0, "verified": 10766, "batches_failed": 13, "hang": false, "seconds": 59.49, "mb_s": 21269, "batch_ms_p50": 42.3, "batch_ms_p99": 57.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000003b": 1, "load missed for m@00000000@0@00000528": 1, "load missed for m@00000000@0@000012bd": 1, "load missed for m@00000000@0@00001676": 1}, "t": 20, "mode": "load", "utc": "09:03:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 25373433659392, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 87052, "miss": 20, "wrong": 0, "verified": 10875, "batches_failed": 20, "hang": false, "seconds": 59.49, "mb_s": 21481, "batch_ms_p50": 41.7, "batch_ms_p99": 57.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000111d": 1, "load missed for m@00000000@0@000005a5": 1, "load missed for m@00000000@0@0000140d": 1, "load missed for m@00000000@0@00000eea": 1}, "t": 21, "mode": "load", "utc": "09:04:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 26651362590720, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86594, "miss": 14, "wrong": 0, "verified": 10823, "batches_failed": 14, "hang": false, "seconds": 59.5, "mb_s": 21364, "batch_ms_p50": 42.2, "batch_ms_p99": 56.6, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000784": 1, "load missed for m@00000000@0@000004c8": 1, "load missed for m@00000000@0@000001ef": 1, "load missed for m@00000000@0@00001658": 1}, "t": 22, "mode": "load", "utc": "09:05:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 27922568052736, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86198, "miss": 10, "wrong": 0, "verified": 10774, "batches_failed": 10, "hang": false, "seconds": 59.49, "mb_s": 21272, "batch_ms_p50": 42.2, "batch_ms_p99": 56.4, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000160c": 1, "load missed for m@00000000@0@00001d0a": 1, "load missed for m@00000000@0@000018a1": 1, "load missed for m@00000000@0@0000104b": 1}, "t": 23, "mode": "load", "utc": "09:06:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 29187960209408, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86376, "miss": 24, "wrong": 0, "verified": 10798, "batches_failed": 24, "hang": false, "seconds": 59.5, "mb_s": 21311, "batch_ms_p50": 42.2, "batch_ms_p99": 57.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@000019aa": 1, "load missed for m@00000000@0@00000906": 1, "load missed for m@00000000@0@00000204": 1, "load missed for m@00000000@0@00000cec": 1}, "t": 24, "mode": "load", "utc": "09:07:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 30455965417472, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86509, "miss": 11, "wrong": 0, "verified": 10806, "batches_failed": 10, "hang": false, "seconds": 59.48, "mb_s": 21351, "batch_ms_p50": 42.0, "batch_ms_p99": 58.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001582": 1, "load missed for m@00000000@0@00000379": 1, "load missed for m@00000000@0@0000087b": 1, "load missed for m@00000000@0@00000047": 1}, "t": 25, "mode": "load", "utc": "09:08:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 31725923074048, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86557, "miss": 11, "wrong": 0, "verified": 10815, "batches_failed": 11, "hang": false, "seconds": 59.49, "mb_s": 21360, "batch_ms_p50": 41.9, "batch_ms_p99": 56.5, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000b80": 1, "load missed for m@00000000@0@00001e77": 1, "load missed for m@00000000@0@00001c12": 1, "load missed for m@00000000@0@000016ce": 1}, "t": 26, "mode": "load", "utc": "09:09:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 32996585373696, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86890, "miss": 14, "wrong": 0, "verified": 10854, "batches_failed": 14, "hang": false, "seconds": 59.49, "mb_s": 21441, "batch_ms_p50": 42.0, "batch_ms_p99": 56.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000d8d": 1, "load missed for m@00000000@0@000007e4": 1, "load missed for m@00000000@0@000013cd": 1, "load missed for m@00000000@0@000013c5": 1}, "t": 27, "mode": "load", "utc": "09:10:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 34272136134656, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86319, "miss": 9, "wrong": 0, "verified": 10781, "batches_failed": 9, "hang": false, "seconds": 59.48, "mb_s": 21303, "batch_ms_p50": 42.3, "batch_ms_p99": 56.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001fdd": 1, "load missed for m@00000000@0@00000dd0": 1, "load missed for m@00000000@0@00000bd2": 1, "load missed for m@00000000@0@00000588": 1}, "t": 28, "mode": "load", "utc": "09:11:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 35539304579072, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 86564, "miss": 20, "wrong": 0, "verified": 10813, "batches_failed": 20, "hang": false, "seconds": 59.49, "mb_s": 21361, "batch_ms_p50": 42.1, "batch_ms_p99": 58.0, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001c83": 1, "load missed for m@00000000@0@00001091": 1, "load missed for m@00000000@0@00000aa6": 1, "load missed for m@00000000@0@00000cc3": 1}, "t": 29, "mode": "load", "utc": "09:12:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 36810069639168, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 77990, "miss": 10, "wrong": 0, "verified": 9741, "batches_failed": 10, "hang": false, "seconds": 53.95, "mb_s": 21221, "batch_ms_p50": 42.3, "batch_ms_p99": 58.0, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00001f98": 1, "load missed for m@00000000@0@000018fd": 1, "load missed for m@00000000@0@0000025c": 1, "load missed for m@00000000@0@00000c79": 1}, "t": 30, "mode": "load", "utc": "09:13:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 37954967830528, "direct_write_bytes": 0, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"total": true, "mode": "load", "ok": 2585477, "miss": 427, "wrong": 0, "verified": 323029} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/monitor.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/monitor.txt new file mode 100644 index 0000000..be3edc2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/monitor.txt @@ -0,0 +1,30 @@ +08:43:30 rss_mb=24 nvme1n1=27 nvme2n1=26 nvme3n1=27 nvme4n1=26 +08:44:30 rss_mb=34 nvme1n1=28 nvme2n1=28 nvme3n1=28 nvme4n1=28 +08:45:30 rss_mb=36 nvme1n1=30 nvme2n1=29 nvme3n1=29 nvme4n1=29 +08:46:30 rss_mb=37 nvme1n1=31 nvme2n1=30 nvme3n1=29 nvme4n1=30 +08:47:30 rss_mb=38 nvme1n1=32 nvme2n1=32 nvme3n1=31 nvme4n1=31 +08:48:30 rss_mb=39 nvme1n1=32 nvme2n1=32 nvme3n1=31 nvme4n1=31 +08:49:30 rss_mb=39 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=32 +08:50:30 rss_mb=39 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=32 +08:51:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=33 nvme4n1=32 +08:52:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=32 +08:53:30 rss_mb=40 nvme1n1=33 nvme2n1=32 nvme3n1=32 nvme4n1=32 +08:54:30 rss_mb=40 nvme1n1=32 nvme2n1=31 nvme3n1=32 nvme4n1=31 +08:55:30 rss_mb=40 nvme1n1=31 nvme2n1=30 nvme3n1=31 nvme4n1=30 +08:56:30 rss_mb=40 nvme1n1=30 nvme2n1=29 nvme3n1=30 nvme4n1=30 +08:57:30 rss_mb=40 nvme1n1=30 nvme2n1=28 nvme3n1=29 nvme4n1=29 +08:58:30 rss_mb=40 nvme1n1=29 nvme2n1=28 nvme3n1=29 nvme4n1=29 +08:59:30 rss_mb=40 nvme1n1=30 nvme2n1=28 nvme3n1=29 nvme4n1=29 +09:00:30 rss_mb=40 nvme1n1=30 nvme2n1=29 nvme3n1=29 nvme4n1=29 +09:01:30 rss_mb=40 nvme1n1=31 nvme2n1=29 nvme3n1=30 nvme4n1=30 +09:02:30 rss_mb=40 nvme1n1=31 nvme2n1=30 nvme3n1=30 nvme4n1=31 +09:03:30 rss_mb=40 nvme1n1=31 nvme2n1=31 nvme3n1=30 nvme4n1=31 +09:04:30 rss_mb=40 nvme1n1=32 nvme2n1=32 nvme3n1=31 nvme4n1=31 +09:05:30 rss_mb=40 nvme1n1=32 nvme2n1=32 nvme3n1=31 nvme4n1=32 +09:06:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=31 nvme4n1=32 +09:07:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=33 +09:08:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=33 +09:09:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=33 nvme4n1=33 +09:10:30 rss_mb=40 nvme1n1=33 nvme2n1=33 nvme3n1=32 nvme4n1=32 +09:11:30 rss_mb=40 nvme1n1=32 nvme2n1=32 nvme3n1=32 nvme4n1=32 +09:12:30 rss_mb=40 nvme1n1=31 nvme2n1=30 nvme3n1=31 nvme4n1=31 diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_after.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_after.txt new file mode 100644 index 0000000..ba7695f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_after.txt @@ -0,0 +1,24 @@ +--- nvme1n1 +critical_warning : 0 +temperature : 30 °C (303 K) +percentage_used : 5% +media_errors : 0 +num_err_log_entries : 0 +--- nvme2n1 +critical_warning : 0 +temperature : 28 °C (301 K) +percentage_used : 14% +media_errors : 0 +num_err_log_entries : 0 +--- nvme3n1 +critical_warning : 0 +temperature : 30 °C (303 K) +percentage_used : 26% +media_errors : 0 +num_err_log_entries : 0 +--- nvme4n1 +critical_warning : 0 +temperature : 30 °C (303 K) +percentage_used : 8% +media_errors : 0 +num_err_log_entries : 0 diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_before.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_before.txt new file mode 100644 index 0000000..cf7c220 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/smart_before.txt @@ -0,0 +1,24 @@ +--- nvme1n1 +critical_warning : 0 +temperature : 23 °C (296 K) +percentage_used : 5% +media_errors : 0 +num_err_log_entries : 0 +--- nvme2n1 +critical_warning : 0 +temperature : 23 °C (296 K) +percentage_used : 14% +media_errors : 0 +num_err_log_entries : 0 +--- nvme3n1 +critical_warning : 0 +temperature : 24 °C (297 K) +percentage_used : 26% +media_errors : 0 +num_err_log_entries : 0 +--- nvme4n1 +critical_warning : 0 +temperature : 23 °C (296 K) +percentage_used : 8% +media_errors : 0 +num_err_log_entries : 0 diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/store.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/store.jsonl new file mode 100644 index 0000000..c9c0193 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/soak/store.jsonl @@ -0,0 +1,31 @@ +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 18.9, "wrong_ids": [], "errors": {}, "t": 1, "mode": "store", "utc": "08:44:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 118967238656, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 2, "mode": "store", "utc": "08:45:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 237934477312, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.6, "wrong_ids": [], "errors": {}, "t": 3, "mode": "store", "utc": "08:46:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 356901715968, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 19.0, "wrong_ids": [], "errors": {}, "t": 4, "mode": "store", "utc": "08:47:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 475868954624, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 5, "mode": "store", "utc": "08:48:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 594836193280, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 19.0, "wrong_ids": [], "errors": {}, "t": 6, "mode": "store", "utc": "08:49:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 713803431936, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 18.9, "wrong_ids": [], "errors": {}, "t": 7, "mode": "store", "utc": "08:50:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 832770670592, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.8, "wrong_ids": [], "errors": {}, "t": 8, "mode": "store", "utc": "08:51:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 951737909248, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.3, "wrong_ids": [], "errors": {}, "t": 9, "mode": "store", "utc": "08:52:31", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1070705147904, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.5, "wrong_ids": [], "errors": {}, "t": 10, "mode": "store", "utc": "08:53:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1189672386560, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.5, "wrong_ids": [], "errors": {}, "t": 11, "mode": "store", "utc": "08:54:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1308639625216, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.47, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 12, "mode": "store", "utc": "08:55:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1427606863872, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.47, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.8, "wrong_ids": [], "errors": {}, "t": 13, "mode": "store", "utc": "08:56:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1546574102528, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.6, "wrong_ids": [], "errors": {}, "t": 14, "mode": "store", "utc": "08:57:32", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1665541341184, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.47, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.5, "wrong_ids": [], "errors": {}, "t": 15, "mode": "store", "utc": "08:58:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1784508579840, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.8, "wrong_ids": [], "errors": {}, "t": 16, "mode": "store", "utc": "08:59:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 1903475818496, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 19.2, "wrong_ids": [], "errors": {}, "t": 17, "mode": "store", "utc": "09:00:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2022443057152, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 18, "mode": "store", "utc": "09:01:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2141410295808, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.8, "wrong_ids": [], "errors": {}, "t": 19, "mode": "store", "utc": "09:02:33", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2260377534464, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 20, "mode": "store", "utc": "09:03:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2379344773120, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 19.2, "wrong_ids": [], "errors": {}, "t": 21, "mode": "store", "utc": "09:04:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2498312011776, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.4, "batch_ms_p99": 18.5, "wrong_ids": [], "errors": {}, "t": 22, "mode": "store", "utc": "09:05:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2617279250432, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.4, "batch_ms_p99": 18.8, "wrong_ids": [], "errors": {}, "t": 23, "mode": "store", "utc": "09:06:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2736246489088, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 19.5, "wrong_ids": [], "errors": {}, "t": 24, "mode": "store", "utc": "09:07:34", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2855213727744, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 19.6, "wrong_ids": [], "errors": {}, "t": 25, "mode": "store", "utc": "09:08:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 2974180966400, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 19.9, "wrong_ids": [], "errors": {}, "t": 26, "mode": "store", "utc": "09:09:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 3093148205056, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 18.7, "wrong_ids": [], "errors": {}, "t": 27, "mode": "store", "utc": "09:10:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 3212115443712, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.7, "batch_ms_p99": 18.9, "wrong_ids": [], "errors": {}, "t": 28, "mode": "store", "utc": "09:11:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 3331082682368, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 8104, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 59.46, "mb_s": 2001, "batch_ms_p50": 14.5, "batch_ms_p99": 18.9, "wrong_ids": [], "errors": {}, "t": 29, "mode": "store", "utc": "09:12:35", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 3450049921024, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"ok": 7352, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 53.93, "mb_s": 2001, "batch_ms_p50": 14.6, "batch_ms_p99": 19.1, "wrong_ids": [], "errors": {}, "t": 30, "mode": "store", "utc": "09:13:30", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 3557977751552, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"total": true, "mode": "store", "ok": 242368, "miss": 0, "wrong": 0, "verified": 0} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.cpu new file mode 100644 index 0000000..1ef4d7e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 24.351893186569214, "user_s": 106.618353, "sys_s": 31.087655, "max_rss_kb": 4046584} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.json new file mode 100644 index 0000000..e869bed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 167.21, + "duration_min_ms": 142.53, + "duration_max_ms": 184.09, + "duration_p50_ms": 168.43, + "duration_p99_ms": 184.09, + "duration_std_ms": 9.06, + "throughput_avg_mbps": 10748.94, + "throughput_min_mbps": 9734.46, + "throughput_max_mbps": 12573.19, + "ops_per_sec_avg": 767.78, + "latency_per_key_ms": 1.306 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 2.78, + "duration_min_ms": 2.5, + "duration_max_ms": 3.03, + "duration_p50_ms": 2.83, + "duration_p99_ms": 3.03, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46107.04, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 111.85, + "duration_min_ms": 105.57, + "duration_max_ms": 122.63, + "duration_p50_ms": 111.76, + "duration_p99_ms": 122.63, + "duration_std_ms": 3.32, + "throughput_avg_mbps": 16035.23, + "throughput_min_mbps": 14613.14, + "throughput_max_mbps": 16974.21, + "ops_per_sec_avg": 1145.37, + "latency_per_key_ms": 0.874 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.cpu new file mode 100644 index 0000000..a131e21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 22.29413914680481, "user_s": 93.869372, "sys_s": 46.450633, "max_rss_kb": 15060068} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.json new file mode 100644 index 0000000..6183117 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w128_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 489.29, + "duration_min_ms": 464.19, + "duration_max_ms": 548.64, + "duration_p50_ms": 485.66, + "duration_p99_ms": 548.64, + "duration_std_ms": 20.21, + "throughput_avg_mbps": 14671.96, + "throughput_min_mbps": 13064.99, + "throughput_max_mbps": 15441.95, + "ops_per_sec_avg": 1048.0, + "latency_per_key_ms": 0.956 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.67, + "duration_min_ms": 10.11, + "duration_max_ms": 11.18, + "duration_p50_ms": 10.69, + "duration_p99_ms": 11.18, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48013.55, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 395.0, + "duration_min_ms": 385.85, + "duration_max_ms": 401.89, + "duration_p50_ms": 394.22, + "duration_p99_ms": 401.89, + "duration_std_ms": 4.55, + "throughput_avg_mbps": 18148.88, + "throughput_min_mbps": 17835.9, + "throughput_max_mbps": 18577.37, + "ops_per_sec_avg": 1296.35, + "latency_per_key_ms": 0.771 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.cpu new file mode 100644 index 0000000..6fc2066 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.747180223464966, "user_s": 107.610486, "sys_s": 33.091039, "max_rss_kb": 4052796} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.json new file mode 100644 index 0000000..629bb4f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":256},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 154.32, + "duration_min_ms": 136.72, + "duration_max_ms": 176.69, + "duration_p50_ms": 152.25, + "duration_p99_ms": 176.69, + "duration_std_ms": 8.87, + "throughput_avg_mbps": 11649.24, + "throughput_min_mbps": 10141.92, + "throughput_max_mbps": 13107.09, + "ops_per_sec_avg": 832.09, + "latency_per_key_ms": 1.206 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 2.61, + "duration_min_ms": 2.48, + "duration_max_ms": 2.98, + "duration_p50_ms": 2.56, + "duration_p99_ms": 2.98, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49174.5, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 115.17, + "duration_min_ms": 107.36, + "duration_max_ms": 129.45, + "duration_p50_ms": 114.57, + "duration_p99_ms": 129.45, + "duration_std_ms": 4.04, + "throughput_avg_mbps": 15578.32, + "throughput_min_mbps": 13843.18, + "throughput_max_mbps": 16691.53, + "ops_per_sec_avg": 1112.74, + "latency_per_key_ms": 0.9 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.cpu new file mode 100644 index 0000000..2d3f449 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 22.560306787490845, "user_s": 94.271312, "sys_s": 50.547332, "max_rss_kb": 15064676} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.json new file mode 100644 index 0000000..b0e3e21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w256_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":256},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 494.2, + "duration_min_ms": 471.0, + "duration_max_ms": 563.24, + "duration_p50_ms": 486.84, + "duration_p99_ms": 563.24, + "duration_std_ms": 21.32, + "throughput_avg_mbps": 14527.58, + "throughput_min_mbps": 12726.44, + "throughput_max_mbps": 15218.58, + "ops_per_sec_avg": 1037.68, + "latency_per_key_ms": 0.965 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.75, + "duration_min_ms": 10.18, + "duration_max_ms": 11.19, + "duration_p50_ms": 10.79, + "duration_p99_ms": 11.19, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47684.01, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 407.83, + "duration_min_ms": 399.32, + "duration_max_ms": 421.49, + "duration_p50_ms": 405.08, + "duration_p99_ms": 421.49, + "duration_std_ms": 6.4, + "throughput_avg_mbps": 17579.91, + "throughput_min_mbps": 17006.22, + "throughput_max_mbps": 17950.37, + "ops_per_sec_avg": 1255.71, + "latency_per_key_ms": 0.797 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.cpu new file mode 100644 index 0000000..8709ba5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 20.28633451461792, "user_s": 107.753252, "sys_s": 30.487144, "max_rss_kb": 4047640} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.json new file mode 100644 index 0000000..5566ef8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 121.63, + "duration_min_ms": 108.24, + "duration_max_ms": 155.91, + "duration_p50_ms": 121.14, + "duration_p99_ms": 155.91, + "duration_std_ms": 7.0, + "throughput_avg_mbps": 14776.4, + "throughput_min_mbps": 11493.47, + "throughput_max_mbps": 16555.19, + "ops_per_sec_avg": 1055.46, + "latency_per_key_ms": 0.95 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 2.67, + "duration_min_ms": 2.45, + "duration_max_ms": 2.99, + "duration_p50_ms": 2.65, + "duration_p99_ms": 2.99, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47973.92, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 95.41, + "duration_min_ms": 92.01, + "duration_max_ms": 101.67, + "duration_p50_ms": 95.02, + "duration_p99_ms": 101.67, + "duration_std_ms": 2.15, + "throughput_avg_mbps": 18790.91, + "throughput_min_mbps": 17625.85, + "throughput_max_mbps": 19477.06, + "ops_per_sec_avg": 1342.21, + "latency_per_key_ms": 0.745 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.cpu new file mode 100644 index 0000000..abc4985 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 20.939202785491943, "user_s": 94.149008, "sys_s": 46.246101, "max_rss_kb": 15056340} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.json new file mode 100644 index 0000000..c362f93 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w32_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 452.11, + "duration_min_ms": 435.82, + "duration_max_ms": 503.65, + "duration_p50_ms": 446.02, + "duration_p99_ms": 503.65, + "duration_std_ms": 16.95, + "throughput_avg_mbps": 15874.02, + "throughput_min_mbps": 14232.1, + "throughput_max_mbps": 16447.07, + "ops_per_sec_avg": 1133.86, + "latency_per_key_ms": 0.883 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.42, + "duration_min_ms": 10.13, + "duration_max_ms": 10.88, + "duration_p50_ms": 10.3, + "duration_p99_ms": 10.88, + "duration_std_ms": 0.23, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49173.1, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 348.02, + "duration_min_ms": 334.95, + "duration_max_ms": 365.24, + "duration_p50_ms": 345.68, + "duration_p99_ms": 365.24, + "duration_std_ms": 8.08, + "throughput_avg_mbps": 20606.95, + "throughput_min_mbps": 19625.22, + "throughput_max_mbps": 21400.11, + "ops_per_sec_avg": 1471.93, + "latency_per_key_ms": 0.68 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.cpu new file mode 100644 index 0000000..e688bd1 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 23.026179790496826, "user_s": 108.171858, "sys_s": 30.047281, "max_rss_kb": 4046180} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.json new file mode 100644 index 0000000..003b3d5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 149.58, + "duration_min_ms": 132.78, + "duration_max_ms": 177.81, + "duration_p50_ms": 148.57, + "duration_p99_ms": 177.81, + "duration_std_ms": 8.68, + "throughput_avg_mbps": 12018.15, + "throughput_min_mbps": 10077.93, + "throughput_max_mbps": 13495.86, + "ops_per_sec_avg": 858.44, + "latency_per_key_ms": 1.169 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 2.67, + "duration_min_ms": 2.48, + "duration_max_ms": 2.94, + "duration_p50_ms": 2.66, + "duration_p99_ms": 2.94, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47971.18, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 107.87, + "duration_min_ms": 102.22, + "duration_max_ms": 124.19, + "duration_p50_ms": 107.14, + "duration_p99_ms": 124.19, + "duration_std_ms": 3.58, + "throughput_avg_mbps": 16628.97, + "throughput_min_mbps": 14429.57, + "throughput_max_mbps": 17531.59, + "ops_per_sec_avg": 1187.78, + "latency_per_key_ms": 0.843 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.cpu new file mode 100644 index 0000000..b082016 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 21.3761887550354, "user_s": 94.055347, "sys_s": 45.804943, "max_rss_kb": 15056220} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.json new file mode 100644 index 0000000..236a58e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/d4/ru_w64_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 463.35, + "duration_min_ms": 447.17, + "duration_max_ms": 525.97, + "duration_p50_ms": 461.96, + "duration_p99_ms": 525.97, + "duration_std_ms": 17.89, + "throughput_avg_mbps": 15489.69, + "throughput_min_mbps": 13628.23, + "throughput_max_mbps": 16029.68, + "ops_per_sec_avg": 1106.41, + "latency_per_key_ms": 0.905 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 10.44, + "duration_min_ms": 10.17, + "duration_max_ms": 10.89, + "duration_p50_ms": 10.41, + "duration_p99_ms": 10.89, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49055.37, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 366.83, + "duration_min_ms": 358.17, + "duration_max_ms": 373.98, + "duration_p50_ms": 365.78, + "duration_p99_ms": 373.98, + "duration_std_ms": 4.6, + "throughput_avg_mbps": 19543.24, + "throughput_min_mbps": 19166.61, + "throughput_max_mbps": 20012.63, + "ops_per_sec_avg": 1395.95, + "latency_per_key_ms": 0.716 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.cpu new file mode 100644 index 0000000..0ee4668 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 11.392319679260254, "user_s": 133.37287, "sys_s": 429.923274, "max_rss_kb": 4050800} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.json new file mode 100644 index 0000000..1027312 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 63.85, + "duration_min_ms": 62.08, + "duration_max_ms": 75.55, + "duration_p50_ms": 63.75, + "duration_p99_ms": 75.55, + "duration_std_ms": 1.63, + "throughput_avg_mbps": 28080.92, + "throughput_min_mbps": 23720.39, + "throughput_max_mbps": 28867.67, + "ops_per_sec_avg": 2005.78, + "latency_per_key_ms": 0.499 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 1.11, + "duration_min_ms": 0.98, + "duration_max_ms": 1.52, + "duration_p50_ms": 1.02, + "duration_p99_ms": 1.52, + "duration_std_ms": 0.16, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 117433.16, + "latency_per_key_ms": 0.009 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 32.89, + "duration_min_ms": 32.28, + "duration_max_ms": 33.99, + "duration_p50_ms": 32.82, + "duration_p99_ms": 33.99, + "duration_std_ms": 0.35, + "throughput_avg_mbps": 54485.18, + "throughput_min_mbps": 52723.51, + "throughput_max_mbps": 55506.9, + "ops_per_sec_avg": 3891.8, + "latency_per_key_ms": 0.257 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.cpu new file mode 100644 index 0000000..1e8c787 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 12.653330564498901, "user_s": 146.679752, "sys_s": 535.32346, "max_rss_kb": 15062372} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.json new file mode 100644 index 0000000..c4d6aeb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w128_if64-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":128},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 16, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 252.76, + "duration_min_ms": 250.52, + "duration_max_ms": 254.45, + "duration_p50_ms": 252.84, + "duration_p99_ms": 254.45, + "duration_std_ms": 0.81, + "throughput_avg_mbps": 28358.84, + "throughput_min_mbps": 28170.79, + "throughput_max_mbps": 28612.1, + "ops_per_sec_avg": 2025.63, + "latency_per_key_ms": 0.494 + }, + "op_1": { + "operation": "Lookup", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 4.71, + "duration_min_ms": 4.61, + "duration_max_ms": 4.76, + "duration_p50_ms": 4.71, + "duration_p99_ms": 4.76, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 108605.14, + "latency_per_key_ms": 0.009 + }, + "op_2": { + "operation": "Load", + "rounds": 16, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 130.27, + "duration_min_ms": 129.81, + "duration_max_ms": 130.66, + "duration_p50_ms": 130.33, + "duration_p99_ms": 130.66, + "duration_std_ms": 0.28, + "throughput_avg_mbps": 55022.4, + "throughput_min_mbps": 54860.47, + "throughput_max_mbps": 55218.11, + "ops_per_sec_avg": 3930.17, + "latency_per_key_ms": 0.254 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.cpu new file mode 100644 index 0000000..d8db6bb --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 11.427088260650635, "user_s": 107.81512, "sys_s": 165.276637, "max_rss_kb": 4046172} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.json new file mode 100644 index 0000000..4112588 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w32_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 63.28, + "duration_min_ms": 60.9, + "duration_max_ms": 66.22, + "duration_p50_ms": 63.16, + "duration_p99_ms": 66.22, + "duration_std_ms": 1.11, + "throughput_avg_mbps": 28326.91, + "throughput_min_mbps": 27063.31, + "throughput_max_mbps": 29427.26, + "ops_per_sec_avg": 2023.35, + "latency_per_key_ms": 0.494 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 1.34, + "duration_min_ms": 0.98, + "duration_max_ms": 2.25, + "duration_p50_ms": 1.22, + "duration_p99_ms": 2.25, + "duration_std_ms": 0.37, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 101831.65, + "latency_per_key_ms": 0.011 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 33.76, + "duration_min_ms": 29.07, + "duration_max_ms": 45.45, + "duration_p50_ms": 31.64, + "duration_p99_ms": 45.45, + "duration_std_ms": 4.58, + "throughput_avg_mbps": 53953.79, + "throughput_min_mbps": 39430.69, + "throughput_max_mbps": 61653.36, + "ops_per_sec_avg": 3853.84, + "latency_per_key_ms": 0.264 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.cpu new file mode 100644 index 0000000..c95bd01 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 11.36273717880249, "user_s": 119.70591, "sys_s": 311.07164, "max_rss_kb": 4046172} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.json new file mode 100644 index 0000000..0c843bf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/sweep/ram/ru_w64_if16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"ram\",\"num_workers\":64},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 14336, + "data_per_round_mb": 1792.0, + "measurement_rounds": 64, + "warmup_rounds": 1, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 63.47, + "duration_min_ms": 62.0, + "duration_max_ms": 67.11, + "duration_p50_ms": 63.35, + "duration_p99_ms": 67.11, + "duration_std_ms": 0.81, + "throughput_avg_mbps": 28240.02, + "throughput_min_mbps": 26701.83, + "throughput_max_mbps": 28901.34, + "ops_per_sec_avg": 2017.14, + "latency_per_key_ms": 0.496 + }, + "op_1": { + "operation": "Lookup", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 0, + "duration_avg_ms": 1.72, + "duration_min_ms": 1.19, + "duration_max_ms": 2.21, + "duration_p50_ms": 1.71, + "duration_p99_ms": 2.21, + "duration_std_ms": 0.32, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 76992.69, + "latency_per_key_ms": 0.013 + }, + "op_2": { + "operation": "Load", + "rounds": 64, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 8192, + "total_success": 8192, + "duration_avg_ms": 32.01, + "duration_min_ms": 30.89, + "duration_max_ms": 34.67, + "duration_p50_ms": 31.89, + "duration_p99_ms": 34.67, + "duration_std_ms": 0.82, + "throughput_avg_mbps": 56020.05, + "throughput_min_mbps": 51682.09, + "throughput_max_mbps": 58016.31, + "ops_per_sec_avg": 4001.43, + "latency_per_key_ms": 0.25 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.cpu new file mode 100644 index 0000000..fba9b9d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.71697497367859, "user_s": 300.309601, "sys_s": 105.751991, "max_rss_kb": 15059232} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.json new file mode 100644 index 0000000..b4f172e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 383.46, + "duration_min_ms": 362.07, + "duration_max_ms": 450.86, + "duration_p50_ms": 381.11, + "duration_p99_ms": 450.86, + "duration_std_ms": 15.46, + "throughput_avg_mbps": 18720.79, + "throughput_min_mbps": 15898.4, + "throughput_max_mbps": 19797.26, + "ops_per_sec_avg": 1337.2, + "latency_per_key_ms": 0.749 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.25, + "duration_min_ms": 9.76, + "duration_max_ms": 10.9, + "duration_p50_ms": 10.24, + "duration_p99_ms": 10.9, + "duration_std_ms": 0.31, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 50013.1, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 318.56, + "duration_min_ms": 307.71, + "duration_max_ms": 323.95, + "duration_p50_ms": 319.6, + "duration_p99_ms": 323.95, + "duration_std_ms": 3.75, + "throughput_avg_mbps": 22504.41, + "throughput_min_mbps": 22126.59, + "throughput_max_mbps": 23294.34, + "ops_per_sec_avg": 1607.46, + "latency_per_key_ms": 0.622 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.cpu new file mode 100644 index 0000000..e90f8d0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.83341073989868, "user_s": 302.611824, "sys_s": 105.82724, "max_rss_kb": 15058940} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.json new file mode 100644 index 0000000..c78647a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 386.24, + "duration_min_ms": 360.8, + "duration_max_ms": 447.58, + "duration_p50_ms": 382.39, + "duration_p99_ms": 447.58, + "duration_std_ms": 16.7, + "throughput_avg_mbps": 18590.76, + "throughput_min_mbps": 16014.89, + "throughput_max_mbps": 19867.06, + "ops_per_sec_avg": 1327.91, + "latency_per_key_ms": 0.754 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 9.28, + "duration_min_ms": 6.48, + "duration_max_ms": 12.05, + "duration_p50_ms": 8.88, + "duration_p99_ms": 12.05, + "duration_std_ms": 1.19, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 56123.56, + "latency_per_key_ms": 0.018 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 318.31, + "duration_min_ms": 308.16, + "duration_max_ms": 326.66, + "duration_p50_ms": 318.65, + "duration_p99_ms": 326.66, + "duration_std_ms": 3.54, + "throughput_avg_mbps": 22521.98, + "throughput_min_mbps": 21943.51, + "throughput_max_mbps": 23261.01, + "ops_per_sec_avg": 1608.71, + "latency_per_key_ms": 0.622 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.cpu new file mode 100644 index 0000000..4939213 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 51.85603332519531, "user_s": 300.646692, "sys_s": 106.018262, "max_rss_kb": 15059972} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.json new file mode 100644 index 0000000..72059f6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w16-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":16},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 384.99, + "duration_min_ms": 362.32, + "duration_max_ms": 518.33, + "duration_p50_ms": 381.83, + "duration_p99_ms": 518.33, + "duration_std_ms": 22.88, + "throughput_avg_mbps": 18671.24, + "throughput_min_mbps": 13829.16, + "throughput_max_mbps": 19783.37, + "ops_per_sec_avg": 1333.66, + "latency_per_key_ms": 0.752 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 11.07, + "duration_min_ms": 9.71, + "duration_max_ms": 11.82, + "duration_p50_ms": 11.08, + "duration_p99_ms": 11.82, + "duration_std_ms": 0.39, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 46300.22, + "latency_per_key_ms": 0.022 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 318.43, + "duration_min_ms": 311.21, + "duration_max_ms": 324.95, + "duration_p50_ms": 318.74, + "duration_p99_ms": 324.95, + "duration_std_ms": 3.38, + "throughput_avg_mbps": 22512.66, + "throughput_min_mbps": 22059.09, + "throughput_max_mbps": 23032.34, + "ops_per_sec_avg": 1608.05, + "latency_per_key_ms": 0.622 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.cpu new file mode 100644 index 0000000..0e1b0dc --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.81856656074524, "user_s": 302.924961, "sys_s": 110.806758, "max_rss_kb": 15057768} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.json new file mode 100644 index 0000000..041ee3a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 381.56, + "duration_min_ms": 360.56, + "duration_max_ms": 452.19, + "duration_p50_ms": 380.02, + "duration_p99_ms": 452.19, + "duration_std_ms": 14.6, + "throughput_avg_mbps": 18810.8, + "throughput_min_mbps": 15851.88, + "throughput_max_mbps": 19880.33, + "ops_per_sec_avg": 1343.63, + "latency_per_key_ms": 0.745 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.47, + "duration_min_ms": 9.85, + "duration_max_ms": 11.16, + "duration_p50_ms": 10.45, + "duration_p99_ms": 11.16, + "duration_std_ms": 0.32, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 48930.94, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 286.96, + "duration_min_ms": 280.46, + "duration_max_ms": 294.33, + "duration_p50_ms": 286.3, + "duration_p99_ms": 294.33, + "duration_std_ms": 3.82, + "throughput_avg_mbps": 24983.05, + "throughput_min_mbps": 24353.21, + "throughput_max_mbps": 25557.91, + "ops_per_sec_avg": 1784.5, + "latency_per_key_ms": 0.56 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.cpu new file mode 100644 index 0000000..42c174d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 50.0019474029541, "user_s": 300.824673, "sys_s": 111.56154, "max_rss_kb": 15057760} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.json new file mode 100644 index 0000000..cb3b13f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 383.42, + "duration_min_ms": 363.49, + "duration_max_ms": 466.42, + "duration_p50_ms": 378.18, + "duration_p99_ms": 466.42, + "duration_std_ms": 18.5, + "throughput_avg_mbps": 18734.34, + "throughput_min_mbps": 15368.17, + "throughput_max_mbps": 19719.82, + "ops_per_sec_avg": 1338.17, + "latency_per_key_ms": 0.749 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.74, + "duration_min_ms": 10.13, + "duration_max_ms": 12.18, + "duration_p50_ms": 10.67, + "duration_p99_ms": 12.18, + "duration_std_ms": 0.42, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47719.59, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 287.71, + "duration_min_ms": 281.45, + "duration_max_ms": 295.84, + "duration_p50_ms": 287.1, + "duration_p99_ms": 295.84, + "duration_std_ms": 3.91, + "throughput_avg_mbps": 24918.24, + "throughput_min_mbps": 24229.17, + "throughput_max_mbps": 25468.17, + "ops_per_sec_avg": 1779.87, + "latency_per_key_ms": 0.562 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.cpu new file mode 100644 index 0000000..b5129f6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 49.66432476043701, "user_s": 300.511961, "sys_s": 108.587197, "max_rss_kb": 15059840} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.json new file mode 100644 index 0000000..a142310 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w32-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":32},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 378.23, + "duration_min_ms": 357.4, + "duration_max_ms": 460.42, + "duration_p50_ms": 376.93, + "duration_p99_ms": 460.42, + "duration_std_ms": 16.04, + "throughput_avg_mbps": 18981.38, + "throughput_min_mbps": 15568.29, + "throughput_max_mbps": 20056.03, + "ops_per_sec_avg": 1355.81, + "latency_per_key_ms": 0.739 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.45, + "duration_min_ms": 10.11, + "duration_max_ms": 12.18, + "duration_p50_ms": 10.42, + "duration_p99_ms": 12.18, + "duration_std_ms": 0.32, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49027.67, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 287.24, + "duration_min_ms": 279.9, + "duration_max_ms": 298.7, + "duration_p50_ms": 286.99, + "duration_p99_ms": 298.7, + "duration_std_ms": 3.93, + "throughput_avg_mbps": 24959.12, + "throughput_min_mbps": 23997.45, + "throughput_max_mbps": 25609.04, + "ops_per_sec_avg": 1782.79, + "latency_per_key_ms": 0.561 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.cpu new file mode 100644 index 0000000..30c7bf0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 60.51926827430725, "user_s": 295.914808, "sys_s": 100.059911, "max_rss_kb": 15058516} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.json new file mode 100644 index 0000000..7be8f21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 405.36, + "duration_min_ms": 385.35, + "duration_max_ms": 471.05, + "duration_p50_ms": 402.4, + "duration_p99_ms": 471.05, + "duration_std_ms": 15.42, + "throughput_avg_mbps": 17706.19, + "throughput_min_mbps": 15217.16, + "throughput_max_mbps": 18601.26, + "ops_per_sec_avg": 1264.73, + "latency_per_key_ms": 0.792 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.87, + "duration_min_ms": 10.21, + "duration_max_ms": 11.39, + "duration_p50_ms": 10.87, + "duration_p99_ms": 11.39, + "duration_std_ms": 0.29, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 47155.74, + "latency_per_key_ms": 0.021 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 448.15, + "duration_min_ms": 421.52, + "duration_max_ms": 463.57, + "duration_p50_ms": 450.13, + "duration_p99_ms": 463.57, + "duration_std_ms": 10.14, + "throughput_avg_mbps": 16002.83, + "throughput_min_mbps": 15462.63, + "throughput_max_mbps": 17005.12, + "ops_per_sec_avg": 1143.06, + "latency_per_key_ms": 0.875 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.cpu new file mode 100644 index 0000000..d720658 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 60.12405800819397, "user_s": 297.554811, "sys_s": 94.543641, "max_rss_kb": 15059684} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.json new file mode 100644 index 0000000..c9b160c --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 404.53, + "duration_min_ms": 385.1, + "duration_max_ms": 481.61, + "duration_p50_ms": 401.8, + "duration_p99_ms": 481.61, + "duration_std_ms": 16.12, + "throughput_avg_mbps": 17744.07, + "throughput_min_mbps": 14883.32, + "throughput_max_mbps": 18613.57, + "ops_per_sec_avg": 1267.43, + "latency_per_key_ms": 0.79 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 9.77, + "duration_min_ms": 6.25, + "duration_max_ms": 11.82, + "duration_p50_ms": 10.06, + "duration_p99_ms": 11.82, + "duration_std_ms": 1.28, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 53523.52, + "latency_per_key_ms": 0.019 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 443.61, + "duration_min_ms": 416.26, + "duration_max_ms": 472.82, + "duration_p50_ms": 443.62, + "duration_p99_ms": 472.82, + "duration_std_ms": 12.39, + "throughput_avg_mbps": 16170.71, + "throughput_min_mbps": 15160.21, + "throughput_max_mbps": 17219.94, + "ops_per_sec_avg": 1155.05, + "latency_per_key_ms": 0.866 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.cpu b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.cpu new file mode 100644 index 0000000..ab47bbf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.cpu @@ -0,0 +1 @@ +{"rc": 0, "wall_s": 60.21928024291992, "user_s": 297.276674, "sys_s": 97.237496, "max_rss_kb": 15059300} \ No newline at end of file diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.json new file mode 100644 index 0000000..c33eeb7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-epyc/workers/fix_14mib_d4_w8-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/run/hc/hc.sock\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 14336, + "data_per_round_mb": 7168.0, + "measurement_rounds": 56, + "warmup_rounds": 2, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 403.12, + "duration_min_ms": 383.14, + "duration_max_ms": 470.8, + "duration_p50_ms": 399.94, + "duration_p99_ms": 470.8, + "duration_std_ms": 11.81, + "throughput_avg_mbps": 17794.99, + "throughput_min_mbps": 15225.14, + "throughput_max_mbps": 18708.59, + "ops_per_sec_avg": 1271.07, + "latency_per_key_ms": 0.787 + }, + "op_1": { + "operation": "Lookup", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 0, + "duration_avg_ms": 10.32, + "duration_min_ms": 10.14, + "duration_max_ms": 10.53, + "duration_p50_ms": 10.32, + "duration_p99_ms": 10.53, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 49598.52, + "latency_per_key_ms": 0.02 + }, + "op_2": { + "operation": "Load", + "rounds": 56, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 28672, + "total_success": 28672, + "duration_avg_ms": 445.62, + "duration_min_ms": 413.13, + "duration_max_ms": 467.48, + "duration_p50_ms": 444.96, + "duration_p99_ms": 467.48, + "duration_std_ms": 11.73, + "throughput_avg_mbps": 16096.77, + "throughput_min_mbps": 15333.41, + "throughput_max_mbps": 17350.63, + "ops_per_sec_avg": 1149.77, + "latency_per_key_ms": 0.87 + } + } +} diff --git a/benchmarks/results/lmcache_rust_connector_nvme.md b/benchmarks/results/lmcache_rust_connector_nvme.md new file mode 100644 index 0000000..41bfabb --- /dev/null +++ b/benchmarks/results/lmcache_rust_connector_nvme.md @@ -0,0 +1,166 @@ +# Rust LMCache connector results: bare metal, 4 NVMe drives + +Measured 2026-11-04 on a rented bare-metal node with no GPU. Raw data is in `lmcache_l2_raw/rust-connector-epyc/`. This page covers storage only: no model ran, so it says nothing about first-token time or output. + +**Hardware:** AMD EPYC 9474F (48 cores, 1 socket, 1 NUMA node), 755 GB DDR5-4800 on 8 channels, 4 Micron 7450 3.84 TB drives (firmware E2MU300, Gen4 x4, 4 KiB blocks), each discarded before a run. + +**Software:** Linux 6.8.0, LMCache 0.5.6, Python 3.12, rustc 1.99.1, HyperCache 0.9.3 plus this branch. The safety script passed 30 of 30 on LMCache 0.5.5 and 0.5.6 on these drives. + +**Method:** `lmcache bench l2`, 8 keys per task, L1 aligned to 4 KiB, 2 warmup rounds, order shuffled, median of 3 runs with the range in brackets. Every run checks that all keys were stored and loaded. 14 MiB is one 256-token Qwen2.5-7B chunk. "Old" is the daemon before the stripe fix (each object starts on the first drive), and "fixed" is after it. + +## Summary + +- **Striping scales linearly with the fix.** 14 MiB objects load at 90% of what the raw drives can do. +- **The stripe fix matters most for small objects.** 2 MiB objects load 3.9 times as fast, because they used to land on one drive. +- **On 4 drives, the connector matches the best `raw_block` result on RAID 0, and holds it.** `raw_block` on RAID 0 reached the same speed in 2 of 6 runs and got stuck near 15.2 GB/s in the other 4. The cause isn't known, and could be our array setup. +- **No load returned wrong bytes** across crashes, restarts, corruption, eviction and a 30-minute soak. +- **Lookups are slower than `raw_block`'s**, at about 2.6 ms against 0.9-1.0 ms on one drive. +- **Full-speed writes cut reads hard.** Most of that comes from the drives themselves. See [mixed reads and writes](#mixed-reads-and-writes). + +## What the drives can do without HyperCache + +fio, 4 MiB blocks, queue depth 32 per drive, 3 runs. Results were tight and linear. + +| Drives | Read MB/s | Write MB/s | +|---|---|---| +| 1 | 6911 | 5398 | +| 2 | 13822 | 10833 | +| 4 | 27643 | 21576 | + +## Stripe fix, old vs fixed + +4 drives unless noted, 64 objects in flight. Old and fixed ran in the same session. + +| Objects, workers | Old load | Fixed load | Old store | Fixed store | +|---|---|---|---|---| +| 2 MiB, 32 | 6321 [6231-6350] | 24609 [24604-24695] | 4962 [4920-4989] | 15390 [15278-15441] | +| 14 MiB, 32 | 20740 [20707-20887] | 24884 [24619-24888] | 16129 [15977-16261] | 18549 [18248-18842] | +| 14 MiB, 128 | 18713 [18622-18781] | 23050 [23016-23173] | 14962 [14519-14983] | 18686 [18202-18893] | +| 16 MiB, 32 | 23587 [23536-23790] | 24646 [24641-24768] | 18144 [18119-18349] | 18759 [18717-18802] | +| 14 MiB, 32, 2 drives | 10526 [10390-10541] | 12071 [12014-12217] | 8745 [8687-8764] | 9608 [9497-9717] | + +Per-drive peak read during a 14 MiB run, from iostat: + +| Drive | Old MB/s | Fixed MB/s | +|---|---|---| +| 1 | 5077 | 5183 | +| 2 | 5072 | 5173 | +| 3 | 5065 | 5172 | +| 4 | 2532 | 5175 | + +## Worker count + +Fixed daemon, 4 drives, 14 MiB, 64 in flight. + +| Workers | Load MB/s | Store MB/s | +|---|---|---| +| 8 | 16097 [16003-16171] | 17744 [17706-17795] | +| 16 | 22513 [22504-22522] | 18671 [18591-18721] | +| 32 | 24959 [24918-24983] | 18811 [18734-18981] | +| 64 | 23357 [23186-23485] | 18586 [18286-18634] | +| 128 | 23050 [23016-23173] | 18686 [18202-18893] | + +The 8, 16 and 32 rows were one batch, and the 64 and 128 rows were another, whose 32-worker result was 24884. On 4 drives, 32 is the best count tested, so it stays the default. On one drive, 8 is better (below), which is about 8 workers per drive. Other drive counts weren't swept. + +## One drive against raw_block + +14 MiB, 16 in flight. `raw_block` here is LMCache's own adapter, which uses one device. + +| Adapter, workers | Store MB/s | Load MB/s | Lookup ms | +|---|---|---|---| +| Rust, 8 | 4954 [4918-4996] | 6458 [6454-6475] | 2.64 | +| Rust, 32 | 4957 [4941-5005] | 5917 [5889-5920] | 2.62 | +| `raw_block` posix, 8 | 4984 [4928-5006] | 6163 [6147-6169] | 0.90 | +| `raw_block` posix, 32 | 4913 [4906-4984] | 5878 [5837-5887] | 1.00 | +| `raw_block` io_uring, 8 | 4968 [4928-4980] | 5976 [5831-5980] | 0.95 | +| `raw_block` io_uring, 32 | 4942 [4915-4985] | 5830 [5714-5915] | 0.97 | + +With 4 in flight, 8 workers: Rust stores at 4917 and loads at 6328 MB/s with 0.72 ms lookups, and `raw_block` io_uring stores at 4880 and loads at 5927 MB/s with 0.27 ms lookups. LMCache logged that io_uring fixed buffers weren't in use in this setup, because no stable L1 range was eligible. + +These one-drive runs used the old daemon. With one drive, every object starts on that drive either way. + +## Multiple drives against raw_block on RAID 0 + +14 MiB, 64 in flight. `raw_block` can only use one device, so to give it all the drives we built Linux md RAID 0 with a 4 MiB chunk, and used io_uring. + +| Setup | Load MB/s | Store MB/s | Lookup ms | +|---|---|---|---| +| Rust, fixed, 4 drives, 32 workers | 24884 [24619-24888] | 18549 [18248-18842] | 10.5 | +| `raw_block` RAID 0, 4 drives, 32 workers | 23042 [15192-24721] | 16855 [16645-18534] | 3.9 | +| `raw_block` RAID 0, 4 drives, 64 workers | 15236 [15163-15324] | 16812 [16479-16940] | 4.0 | +| Rust, fixed, 2 drives, 32 workers | 12071 [12014-12217] | 9608 [9497-9717] | 10.3 | +| `raw_block` RAID 0, 2 drives, 64 workers | 11548 [11439-11606] | 9810 [9805-9831] | 3.9 | +| `raw_block` RAID 0, 2 drives, 32 workers | 10727 [10677-10794] | 9669 [9649-9701] | 3.9 | + +Don't read the stuck 15.2 GB/s runs as a general fault of RAID 0 or `raw_block`. It could come from either of those or from our array settings, and we didn't look for the cause. The comparison shows what we measured, without tuning `raw_block`'s setup. + +## Mixed reads and writes + +No LMCache in the path. 4 drives, 14 MiB, one connector per direction with 32 workers and 64 in flight, 30 s each, 3 rounds, new keys for writes. Reads are in random order. + +| Writes limited to | Read MB/s | Write MB/s | Read batch p50 / p99 ms | +|---|---|---|---| +| Reads only | 25420 | none | 36.9 / 43.5 | +| 1 GB/s | 24181 | 1000 | 37.8 / 50.2 | +| 4 GB/s | 19099 | 4001 | 49.5 / 59.9 | +| No limit | 6478 | 12163 | 144.6 / 187.4 | +| Writes only | none | 20048 | not applicable | + +The same mix on the drives with fio and no HyperCache, as a rough guide. Its queue depths differ (32 for reads, 16 for writes, per drive). + +| Writes limited to | Read MB/s | Write MB/s | +|---|---|---| +| Reads only | 27650 | none | +| 4.2 GB/s | 20637 | 4194 | +| No limit | 10715 | 10663 | + +- **The drives account for most of the drop.** Reads fall by about 25% with 4 GB/s of writes and about 60% with unlimited writes, with no HyperCache involved. Adding an fsync every 4 writes made no difference in fio. +- **At full write speed, the connector leans further towards writes than fio did:** reads at 6478 against 10715, and writes at 12163 against 10663. The cause isn't known, and different queue depths could explain part of it. + +## Failure tests + +Rule: a load is a miss or the right bytes. Each object carries its ID, a generation and its position every 4 KiB, so stale, misplaced or half-replaced data is caught. Results are in `failure/` and `failure_final/`. + +| Test | Result | +|---|---| +| `kill -9` during loads, with and without saved metadata | No hangs or wrong bytes, and it recovers after restart | +| `kill -9` during stores, with and without saved metadata | Same. With saved metadata, 1402 of 1436 acknowledged objects came back and the rest were misses | +| Restart with saved metadata, clean or `kill -9`, straight after storing | All 512 objects came back | +| Blocks freed and reused by other objects, then a crash, grace period 0 or 1 s | Deleted objects miss, live objects are right | +| One 4 KiB block corrupted on disk | Exactly one object missed | +| 1 GiB corrupted on disk | 294 objects missed, 294 checksum failures, none wrong | +| Storing again after corruption | All 512 objects read back right | +| 20 GiB capacity limit under load, 80 GiB stored twice | No wrong bytes. 38 of about 11,500 stores failed at commit, because the object was evicted first. They were reported as failures | +| Full 20 GiB device under load, 80 GiB stored twice | No wrong bytes, no failed stores | + +`failure_final/` is the final connector, which reconnects after a daemon restart. The corruption and eviction rows are from `failure/`, before that change, which doesn't touch those paths. In `failure/`, each worker's first store after a restart fails with a broken pipe, which is what the change fixed. + +## Upgrading + +- **Connector branch, old daemon to fixed and back:** all 512 objects from each version read back right after the upgrade and the rollback, with a clean stop and with `kill -9`. +- **Main's daemon to main plus the fix and back, with the Python client:** 300 objects of 2, 14 and 16 MiB, compared byte for byte, all right at every step, both ways of stopping. Results are in `main_upgrade/`. + +Objects keep the placement they were stored with, so existing objects aren't rebalanced. + +## Soak + +30 minutes, 8192 objects of 14 MiB, 4 drives. Reads ran as fast as they could while 2 GB/s of writes deleted and stored the same objects. Every 8th batch of reads was checked. + +| Measure | Result | +|---|---| +| Loads | 2,585,477 | +| Loads checked byte for byte | 323,029, none wrong | +| Misses | 427 (0.017%), which is expected when an object is being replaced | +| Read speed per minute | 20874-21497 MB/s, median 21352 | +| Write speed per minute | 2001 MB/s throughout | +| Read batch latency | p50 42 ms, worst minute's p99 58.5 ms | +| Daemon memory | 24 MB at the start, 40 MB at most | +| Hottest drive reading | 33 C | +| Stores failed, checksum failures | 0, 0 | +| Kernel NVMe errors, media errors | 0, 0 | + +## Not covered + +- **Real vLLM:** first-token time, output comparison and concurrent traffic need a GPU. +- **RAM tier:** set aside for now. A short sweep loaded at about 55 GB/s, and the limit wasn't investigated. +- **Other hardware:** results at this drive speed may not carry over to consumer drives. diff --git a/client-py/README.md b/client-py/README.md index a8bcc7d..c893660 100644 --- a/client-py/README.md +++ b/client-py/README.md @@ -67,6 +67,12 @@ if layout.is_hit: --- +## LMCache + +The LMCache integration isn't part of this package. It's a separate Rust connector, covered in [`lmcache-connector/README.md`](../lmcache-connector/README.md). For code that manages its own KV blocks, use `HyperCacheKVStore` from this package. + +--- + ## Running Unit Tests ```bash diff --git a/lmcache-connector/README.md b/lmcache-connector/README.md index 8acfef8..8d13e27 100644 --- a/lmcache-connector/README.md +++ b/lmcache-connector/README.md @@ -34,13 +34,20 @@ pip install target/wheels/hypercache_lmcache_native-*.whl | `namespace` | Required. Must change when the model weights, dtype or engine settings change. LMCache's key has a model name but no revision, so without this a weight change could return wrong KV data. | | `socket_path` | Daemon socket. Defaults to the same search order as the Python client. | | `tier` | `nvme` (default) or `ram`. For `ram`, LMCache must share `/dev/shm` with the daemon. | -| `num_workers` | Objects read or written at once, per direction (default 32). On one drive, 8 is enough. | +| `num_workers` | Objects read or written at once, per direction (default 32). Each object is read one chunk at a time, so this sets the queue depth. On one drive, 8 loaded fastest. On 4 drives, 32 did. | | `timeout_s` | Daemon request timeout in seconds (default 30). Commits get at least 300. | | `max_capacity_gb` | Keep at 0. The daemon owns capacity and evicts under pressure. | +## What isn't supported + +- `list_l2_keys` and LMCache's IsolatedLRU quotas. +- Versions other than LMCache 0.5.5 and 0.5.6, which are the ones tested. Nothing in the connector enforces that yet. +- A daemon without `local_only` commits. Stores fail before writing any data, and lookups miss. + ## Behaviour - Any doubt about a block is a miss. Lookup only accepts committed local-only blocks with a checksum for every chunk, and load verifies every chunk before reporting success. +- If the daemon restarts, the connector reconnects by itself. A request that couldn't be sent is resent once, and one the daemon may have received is never resent, so it reports a failure. - Blocks are never flushed to a backend. Against an older daemon, stores fail before any data is written and lookups miss. - A block that fails its checksum is evicted, unless it was replaced during the read. - On raw block devices, writes use O_DIRECT. Page-aligned L1 buffers (`--l1-align-bytes 4096`) go to and from the drive with no copy. A partial last block goes through the page cache on writes and an aligned copy on reads. @@ -61,4 +68,4 @@ cargo test # no Python, LMCache or GPU needed python3 scripts/e2e/lmcache_l2_e2e.py --socket /run/hc/hc.sock ``` -The second needs a running daemon on a real device, and damages one stored chunk on purpose. Results are in `benchmarks/results/lmcache_rust_connector.md` and `lmcache_rust_connector_xeon.md`. +The second needs a running daemon on a real device, and damages one stored chunk on purpose. Results are in `benchmarks/results/lmcache_rust_connector.md`, `lmcache_rust_connector_xeon.md` and `lmcache_rust_connector_nvme.md`. From a67a90013d4e3171476a373ae377a519a0bd0659 Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 03:39:53 -0600 Subject: [PATCH 5/9] test(e2e): read each chunk from its own drive in the coherence check The page cache check read every chunk through a descriptor for the object's first drive, so it only held for one drive. It failed on 4 drives once objects started on different drives. It had passed before most likely by accident: the test data repeats every 32 bytes, and the old allocator kept drives' offsets in step. Passes 30 of 30 on LMCache 0.5.5 and 0.5.6, on 1 and 4 drives. --- benchmarks/results/lmcache_rust_connector_nvme.md | 2 +- scripts/e2e/lmcache_l2_e2e.py | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/benchmarks/results/lmcache_rust_connector_nvme.md b/benchmarks/results/lmcache_rust_connector_nvme.md index 41bfabb..5afbc27 100644 --- a/benchmarks/results/lmcache_rust_connector_nvme.md +++ b/benchmarks/results/lmcache_rust_connector_nvme.md @@ -4,7 +4,7 @@ Measured 2026-11-04 on a rented bare-metal node with no GPU. Raw data is in `lmc **Hardware:** AMD EPYC 9474F (48 cores, 1 socket, 1 NUMA node), 755 GB DDR5-4800 on 8 channels, 4 Micron 7450 3.84 TB drives (firmware E2MU300, Gen4 x4, 4 KiB blocks), each discarded before a run. -**Software:** Linux 6.8.0, LMCache 0.5.6, Python 3.12, rustc 1.99.1, HyperCache 0.9.3 plus this branch. The safety script passed 30 of 30 on LMCache 0.5.5 and 0.5.6 on these drives. +**Software:** Linux 6.8.0, LMCache 0.5.6, Python 3.12, rustc 1.99.1, HyperCache 0.9.3 plus this branch. The safety script (`scripts/e2e/lmcache_l2_e2e.py`) passed 30 of 30 on the final code, on LMCache 0.5.5 and 0.5.6, on 1 and 4 drives (`safety_final/`). **Method:** `lmcache bench l2`, 8 keys per task, L1 aligned to 4 KiB, 2 warmup rounds, order shuffled, median of 3 runs with the range in brackets. Every run checks that all keys were stored and loaded. 14 MiB is one 256-token Qwen2.5-7B chunk. "Old" is the daemon before the stripe fix (each object starts on the first drive), and "fixed" is after it. diff --git a/scripts/e2e/lmcache_l2_e2e.py b/scripts/e2e/lmcache_l2_e2e.py index 7fb7a4f..cd99cca 100644 --- a/scripts/e2e/lmcache_l2_e2e.py +++ b/scripts/e2e/lmcache_l2_e2e.py @@ -136,7 +136,7 @@ def mixed_writes_are_coherent(client): buffered = DirectBlockWriter(max_workers=4) direct = DirectBlockWriter(max_workers=4, direct_on_block_devices=True) direct_reader = DirectBlockReader(max_workers=4, verify_checksums=False) - plain = os.open(layout[0].device, os.O_RDONLY) + plain = {device: os.open(device, os.O_RDONLY) for device in {chunk.device for chunk in layout}} aligned = mmap.mmap(-1, size) view = memoryview(aligned) @@ -145,7 +145,7 @@ def read_both(): direct_reader.read_range_into(layout, 0, size, through_direct) through_cache, position = bytearray(size), 0 for chunk in layout: - through_cache[position : position + chunk.length] = os.pread(plain, chunk.length, chunk.offset) + through_cache[position : position + chunk.length] = os.pread(plain[chunk.device], chunk.length, chunk.offset) position += chunk.length return bytes(through_direct), bytes(through_cache) @@ -159,7 +159,8 @@ def read_both(): return True finally: view.release() - os.close(plain) + for fd in plain.values(): + os.close(fd) direct_reader.close() direct.close() buffered.close() @@ -308,7 +309,7 @@ def main(): wrong = load(adapter, keys[1:2], [Obj(bytes(size - 4096))]) results.append(check("wrong buffer size is a miss", wrong == [False])) - results.append(check("page cache and O_DIRECT stay coherent on one device", mixed_writes_are_coherent(client))) + results.append(check("page cache and O_DIRECT stay coherent", mixed_writes_are_coherent(client))) adapter.delete(keys) adapter.submit_unlock(keys) From 275770eec10d98362bc832f31c4c019b15daea1a Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 20:35:16 -0600 Subject: [PATCH 6/9] perf(connector): send lookups in batches and use 4 lookup workers Each lookup made one socket round trip per key on 2 workers, which took most of the lookup time. A batch's locate requests now go out in one write, up to 64 keys or 64 KiB, and the replies are read in order. The daemon and its protocol don't change, so this works with existing daemons. At 64 in flight through LMCache on a Ryzen 5 5600, hits went from about 12.0 to 3.7 us per key and misses from about 9.8 to 2.4. raw_block is about 4.3 and 3.9 on the same CPU. If a batch fails part-way, no key in it is reported as found. A timeout or reset drops the connection, so a late reply can't be read as the answer to a later lookup. --- lmcache-connector/src/connector.rs | 47 ++++++-- lmcache-connector/src/daemon.rs | 171 ++++++++++++++++++++++++++++- 2 files changed, 202 insertions(+), 16 deletions(-) diff --git a/lmcache-connector/src/connector.rs b/lmcache-connector/src/connector.rs index e04d065..a51bc93 100644 --- a/lmcache-connector/src/connector.rs +++ b/lmcache-connector/src/connector.rs @@ -25,7 +25,7 @@ use std::sync::{Arc, Condvar, Mutex}; use std::thread::JoinHandle; use std::time::Duration; -const LOOKUP_WORKERS: usize = 2; +const LOOKUP_WORKERS: usize = 4; #[derive(Clone, Debug)] pub struct Config { @@ -665,19 +665,24 @@ impl Worker { } } - /// A daemon failure fails the whole batch, which LMCache treats as all misses. + /// A daemon failure fails the whole batch, which LMCache treats as all misses. A malformed key + /// is a miss for that key alone. fn exists(&mut self, batch: &Batch, keys: &[String]) { let shared = self.shared.clone(); - for (index, key) in keys.iter().enumerate() { - let Ok(uri) = shared.uri_for(key) else { continue }; - match self.client.locate(&uri) { - Ok(location) if location.is_valid_block() => batch.results[index].store(1, SeqCst), - Ok(_) => {} - Err(error) => { - record_failure(batch, format!("lookup failed: {error}")); - return; + let (indexes, uris): (Vec, Vec) = keys + .iter() + .enumerate() + .filter_map(|(index, key)| Some((index, shared.uri_for(key).ok()?))) + .unzip(); + match self.client.locate_many(&uris) { + Ok(locations) => { + for (index, location) in indexes.into_iter().zip(locations) { + if location.is_valid_block() { + batch.results[index].store(1, SeqCst); + } } } + Err(error) => record_failure(batch, format!("lookup failed: {error}")), } } @@ -946,6 +951,28 @@ mod tests { const SIZE: usize = 14 * 1024 * 1024 + 123; + /// More keys than one write of lookups holds, mixing hits, misses, staged blocks and a bad key. + #[test] + fn large_lookup_reports_each_key_correctly() { + let daemon = FakeDaemon::start("largelookup", false); + let connector = daemon.connector("ns"); + let long_key = |n: usize| format!("Qwen/test@00000000@0@{n:04x}ab"); + let stored: Vec = (0..300).step_by(3).map(long_key).collect(); + let mut sources: Vec = stored.iter().map(|_| Aligned::new(&[7u8; 4096])).collect(); + assert!(store(&connector, &stored, &mut sources).ok); + + let mut staged = DaemonClient::new(daemon.socket.clone(), Duration::from_secs(5)); + staged + .stage_write(&connector.uri(&long_key(1)).unwrap(), 4096, "nvme") + .unwrap(); + + let mut query: Vec = (0..300).map(long_key).collect(); + query[4] = "not-a-key".into(); + let results = exists(&connector, &query); + let wanted: Vec = (0..300).map(|n| n % 3 == 0).collect(); + assert_eq!(results, wanted); + } + #[test] fn round_trip_with_partial_last_block() { let daemon = FakeDaemon::start("roundtrip", false); diff --git a/lmcache-connector/src/daemon.rs b/lmcache-connector/src/daemon.rs index 9a2c771..40c7d6f 100644 --- a/lmcache-connector/src/daemon.rs +++ b/lmcache-connector/src/daemon.rs @@ -72,6 +72,11 @@ fn connection_is_dead(error: &io::Error) -> bool { matches!(error.kind(), io::ErrorKind::BrokenPipe | io::ErrorKind::ConnectionReset) } +/// Limits on one write of lookups. The daemon answers each line before it reads the next, so these +/// requests have to fit in the socket buffer, or both sides could block on a full buffer. +const LOOKUP_BATCH_KEYS: usize = 64; +const LOOKUP_BATCH_BYTES: usize = 64 * 1024; + pub struct DaemonClient { socket_path: PathBuf, timeout: Duration, @@ -105,19 +110,25 @@ impl DaemonClient { fn exchange(&mut self, body: &Value, timeout: Duration) -> io::Result { let mut message = serde_json::to_vec(body)?; message.push(b'\n'); + self.send_reconnecting(&message, timeout)?; + self.read_response() + } - // A kept connection dies when the daemon restarts, and the next write is what finds out. - // The daemon can't have received that request, so resending it is safe. A failure after - // this point is never resent, because the daemon may already have acted on the request. + /// A kept connection dies when the daemon restarts, and the next write is what finds out. The + /// daemon can't have received that request, so resending it is safe. A failure after this + /// point is never resent, because the daemon may already have acted on the request. + fn send_reconnecting(&mut self, message: &[u8], timeout: Duration) -> io::Result<()> { let reused = self.stream.is_some(); - match self.send(&message, timeout) { + match self.send(message, timeout) { Err(error) if reused && connection_is_dead(&error) => { self.stream = None; - self.send(&message, timeout)?; + self.send(message, timeout) } - other => other?, + other => other, } + } + fn read_response(&mut self) -> io::Result { let reader = self.stream.as_mut().expect("connected by send"); loop { self.line.clear(); @@ -150,6 +161,33 @@ impl DaemonClient { self.request(&body, self.timeout) } + /// Looks up many objects, one reply per URI in the same order. The requests go out together, + /// which avoids most of the cost of a round trip per key. The daemon answers in order on one + /// connection, so a reply can't be matched to the wrong URI. Any failure fails the whole call. + pub fn locate_many(&mut self, uris: &[String]) -> io::Result> { + let mut responses = Vec::with_capacity(uris.len()); + let mut rest = uris; + while !rest.is_empty() { + let (message, count) = lookup_message(rest)?; + let result = self.locate_group(&message, count, &mut responses); + if result.is_err() { + // A timeout or reset leaves the stream at an unknown position: start clean next time + self.stream = None; + return result.map(|_| Vec::new()); + } + rest = &rest[count..]; + } + Ok(responses) + } + + fn locate_group(&mut self, message: &[u8], count: usize, responses: &mut Vec) -> io::Result<()> { + self.send_reconnecting(message, self.timeout)?; + for _ in 0..count { + responses.push(self.read_response()?); + } + Ok(()) + } + pub fn stage_write(&mut self, uri: &str, size: u64, tier: &str) -> io::Result { let body = json!({ "action": "stage_write", @@ -189,6 +227,24 @@ impl DaemonClient { } } +/// Builds as many locate requests as fit the limits, always at least one. +fn lookup_message(uris: &[String]) -> io::Result<(Vec, usize)> { + let mut message = Vec::new(); + let mut count = 0; + for uri in uris.iter().take(LOOKUP_BATCH_KEYS) { + let before = message.len(); + let body = json!({"action": "locate", "uri": uri, "auto_ingest": false, "pinned": false}); + serde_json::to_writer(&mut message, &body)?; + message.push(b'\n'); + if count > 0 && message.len() > LOOKUP_BATCH_BYTES { + message.truncate(before); + break; + } + count += 1; + } + Ok((message, count)) +} + #[cfg(test)] mod tests { use super::*; @@ -281,4 +337,107 @@ mod tests { assert!(client.locate("hypercache://a").is_err()); let _ = std::fs::remove_dir_all(socket.parent().unwrap()); } + + fn uris(count: usize) -> Vec { + (0..count).map(|i| format!("hypercache://object/{i}")).collect() + } + + fn lines_in(message: &[u8]) -> usize { + message.iter().filter(|b| **b == b'\n').count() + } + + #[test] + fn lookup_message_respects_its_limits() { + let (message, count) = lookup_message(&uris(LOOKUP_BATCH_KEYS + 5)).unwrap(); + assert_eq!(count, LOOKUP_BATCH_KEYS); + assert_eq!(lines_in(&message), LOOKUP_BATCH_KEYS); + + let long: Vec = (0..10) + .map(|i| format!("hypercache://{i}/{}", "x".repeat(20_000))) + .collect(); + let (message, count) = lookup_message(&long).unwrap(); + assert_eq!(count, 3); + assert_eq!(lines_in(&message), 3); + assert!(message.len() <= LOOKUP_BATCH_BYTES); + + // One URI over the limit still goes out, on its own + let huge = vec!["x".repeat(LOOKUP_BATCH_BYTES * 2), "y".into()]; + assert_eq!(lookup_message(&huge).unwrap().1, 1); + } + + /// Answers every line with its own URI, in order, until the client hangs up. + fn echo_uris(stream: UnixStream) { + let mut reader = BufReader::new(stream); + let mut line = String::new(); + while reader.read_line(&mut line).unwrap_or(0) > 0 { + let request: Value = serde_json::from_str(&line).unwrap(); + let reply = json!({"status": "MISS", "error_message": request["uri"]}); + reader.get_mut().write_all(format!("{reply}\n").as_bytes()).unwrap(); + line.clear(); + } + } + + #[test] + fn locate_many_keeps_replies_in_order_across_groups() { + let socket = socket_path("many"); + let listener = UnixListener::bind(&socket).unwrap(); + let server = std::thread::spawn(move || echo_uris(listener.accept().unwrap().0)); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + let wanted = uris(LOOKUP_BATCH_KEYS * 3 + 7); + let replies = client.locate_many(&wanted).unwrap(); + let got: Vec<&str> = replies.iter().map(|r| r.message()).collect(); + assert_eq!(got, wanted.iter().map(String::as_str).collect::>()); + assert!(client.locate_many(&[]).unwrap().is_empty()); + drop(client); + server.join().unwrap(); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } + + #[test] + fn locate_many_survives_a_daemon_restart_on_a_kept_connection() { + let socket = socket_path("many-restart"); + let listener = UnixListener::bind(&socket).unwrap(); + let requests = AtomicUsize::new(0); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + std::thread::scope(|scope| { + scope.spawn(|| answer_one(&listener, &requests)); + client.locate("hypercache://a").unwrap(); + }); + // The old connection is closed now, so the whole write should go out again on a new one + listener.set_nonblocking(false).unwrap(); + let server = std::thread::spawn(move || echo_uris(listener.accept().unwrap().0)); + assert_eq!(client.locate_many(&uris(3)).unwrap().len(), 3); + drop(client); + server.join().unwrap(); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } + + #[test] + fn locate_many_fails_whole_when_the_daemon_dies_part_way() { + let (near, far) = UnixStream::pair().unwrap(); + let socket = socket_path("many-dies"); + let listener = UnixListener::bind(&socket).unwrap(); + let mut client = DaemonClient::new(socket.clone(), TIMEOUT); + client.stream = Some(BufReader::new(near)); + let daemon = std::thread::spawn(move || { + let mut reader = BufReader::new(far); + let mut line = String::new(); + reader.read_line(&mut line).unwrap(); + reader.get_mut().write_all(b"{\"status\":\"HIT\"}\n").unwrap(); + }); + assert!(client.locate_many(&uris(4)).is_err()); + daemon.join().unwrap(); + assert!( + client.stream.is_none(), + "the stream position is unknown, so it must not be reused" + ); + + // The next call starts clean, and no reply from the old connection can be read by it + let server = std::thread::spawn(move || echo_uris(listener.accept().unwrap().0)); + let replies = client.locate_many(&uris(2)).unwrap(); + assert_eq!(replies[1].message(), "hypercache://object/1"); + drop(client); + server.join().unwrap(); + let _ = std::fs::remove_dir_all(socket.parent().unwrap()); + } } From a7ef4db9a0f4dfbe29c51225b5c8d23078753d9d Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 20:46:02 -0600 Subject: [PATCH 7/9] docs(benchmarks): add lookup speed and safety results for batched lookups Measured on a Ryzen 5 5600: lookups through LMCache, hits and misses, against raw_block and fs_native, plus their effect on loads. The safety script and failure tests passed on the final code, on loop devices on a RAM disk. The speed hasn't been repeated on the EPYC node. --- .../failure/results.jsonl | 19 +++++ .../lmcache/fs_native-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/fs_native-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/fs_native-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/fs_native-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/fs_native-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/fs_native-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/fs_native-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/raw_block-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/raw_block-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_batch-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w2_single-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_batch-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if16-hit1.0-3.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit0-1.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit0-2.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit0-3.json | 73 ++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit1.0-1.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit1.0-2.json | 76 +++++++++++++++++++ .../lmcache/rust_w4_single-if64-hit1.0-3.json | 76 +++++++++++++++++++ .../loads_with_fixed_rate_lookups.txt | 14 ++++ .../loads_with_unlimited_lookups.txt | 16 ++++ .../results/lmcache_rust_connector_nvme.md | 34 ++++++++- 76 files changed, 5446 insertions(+), 1 deletion(-) create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/failure/results.jsonl create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-1.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-2.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-3.json create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_fixed_rate_lookups.txt create mode 100644 benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_unlimited_lookups.txt diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/failure/results.jsonl b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/failure/results.jsonl new file mode 100644 index 0000000..2b0e417 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/failure/results.jsonl @@ -0,0 +1,19 @@ +{"test": "lookup_every_result_matches_its_key", "passed": true, "utc": "02:24:58", "stored": 256, "exact": {"rounds": 2000, "wrong_results": 0, "failed": 0}} +{"test": "lookup_kill9_meta_False", "passed": true, "utc": "02:25:17", "during": [{"ok": 11569, "failed": 9096, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 11292, "failed": 9115, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 11473, "failed": 9046, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 11537, "failed": 9129, "false_hits": 0, "lost": 0, "hung": 0}], "after_restart": {"rounds": 300, "wrong_results": 0, "failed": 0}, "after_new_data": {"rounds": 300, "wrong_results": 0, "failed": 0}} +{"test": "lookup_kill9_meta_True", "passed": true, "utc": "02:25:39", "during": [{"ok": 10660, "failed": 9124, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 10364, "failed": 9115, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 10459, "failed": 9076, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 10575, "failed": 9136, "false_hits": 0, "lost": 0, "hung": 0}], "after_restart": {"rounds": 300, "wrong_results": 0, "failed": 0}, "after_new_data": {"rounds": 300, "wrong_results": 0, "failed": 0}} +{"test": "lookup_frozen_daemon", "passed": true, "utc": "02:26:10", "failed_batches_while_frozen": 16, "rounds": [{"during": [{"ok": 2666, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2796, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2794, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2716, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}], "after": {"rounds": 200, "wrong_results": 0, "failed": 0}}, {"during": [{"ok": 3030, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3010, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2904, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2929, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}], "after": {"rounds": 200, "wrong_results": 0, "failed": 0}}, {"during": [{"ok": 3093, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 2970, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3013, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3076, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}], "after": {"rounds": 200, "wrong_results": 0, "failed": 0}}, {"during": [{"ok": 3187, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3137, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3298, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 3335, "failed": 1, "false_hits": 0, "lost": 0, "hung": 0}], "after": {"rounds": 200, "wrong_results": 0, "failed": 0}}]} +{"test": "lookup_with_deletes", "passed": true, "utc": "02:26:21", "during": [{"ok": 2022, "failed": 0, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 1935, "failed": 0, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 1935, "failed": 0, "false_hits": 0, "lost": 0, "hung": 0}, {"ok": 1940, "failed": 0, "false_hits": 0, "lost": 0, "hung": 0}], "after": {"rounds": 300, "wrong_results": 0, "failed": 0}, "load_kept": {"ok": 128, "miss": 0, "wrong": 0, "verified": 128, "batches_failed": 0, "hang": false, "seconds": 0.37, "mb_s": 5093, "batch_ms_p50": 109.5, "batch_ms_p99": 160.1, "wrong_ids": [], "errors": {}}} +{"test": "kill9_during_load_meta_False", "passed": true, "utc": "02:26:40", "stored": 256, "during": {"ok": 360, "miss": 2528, "wrong": 0, "verified": 360, "batches_failed": 316, "hang": false, "seconds": 3.01, "mb_s": 1758, "batch_ms_p50": 25.4, "batch_ms_p99": 131.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000006e": 1, "load missed for m@00000000@0@00000077": 1, "load missed for m@00000000@0@00000078": 4, "load missed for m@00000000@0@00000085": 1}}, "after_same_connector": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.4, "batch_ms_p99": 43.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000005": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000014": 1, "load missed for m@00000000@0@00000019": 1}}, "after_new_connector": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.6, "batch_ms_p99": 43.4, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000005": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000014": 1, "load missed for m@00000000@0@0000001b": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.11, "mb_s": 8247, "batch_ms_p50": 102.5, "batch_ms_p99": 110.0, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.19, "mb_s": 5076, "batch_ms_p50": 90.4, "batch_ms_p99": 101.1, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 2528, "store_failures": 0, "direct_read_bytes": 6224347136, "direct_write_bytes": 4697620480, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_load_meta_True", "passed": true, "utc": "02:27:03", "stored": 256, "during": {"ok": 360, "miss": 2560, "wrong": 0, "verified": 360, "batches_failed": 320, "hang": false, "seconds": 3.01, "mb_s": 1756, "batch_ms_p50": 25.1, "batch_ms_p99": 143.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000006b": 1, "load missed for m@00000000@0@00000073": 1, "load missed for m@00000000@0@0000007d": 1, "load missed for m@00000000@0@00000081": 1}}, "after_same_connector": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5069, "batch_ms_p50": 106.3, "batch_ms_p99": 188.3, "wrong_ids": [], "errors": {}}, "after_new_connector": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5112, "batch_ms_p50": 104.8, "batch_ms_p99": 188.8, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.2, "mb_s": 4764, "batch_ms_p50": 175.8, "batch_ms_p99": 194.1, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.19, "mb_s": 5045, "batch_ms_p50": 94.7, "batch_ms_p99": 100.3, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 2560, "store_failures": 0, "direct_read_bytes": 9982443520, "direct_write_bytes": 4697620480, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_False", "passed": true, "utc": "02:27:23", "during": {"ok": 308, "miss": 55124, "wrong": 0, "verified": 0, "batches_failed": 6891, "hang": false, "seconds": 2.99, "mb_s": 1510, "batch_ms_p50": 1.0, "batch_ms_p99": 2.1, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00000158: Connection refused (os error 111)": 7, "store failed for m@00000000@0@00000160: Connection refused (os error 111)": 10, "store failed for m@00000000@0@00000168: Connection refused (os error 111)": 10, "store failed for m@00000000@0@00000170: Connection refused (os error 111)": 12}}, "after": {"ok": 0, "miss": 4096, "wrong": 0, "verified": 0, "batches_failed": 512, "hang": false, "seconds": 3.12, "mb_s": 0, "batch_ms_p50": 24.6, "batch_ms_p99": 42.8, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000002": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000012": 1, "load missed for m@00000000@0@00000019": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.11, "mb_s": 8206, "batch_ms_p50": 100.9, "batch_ms_p99": 110.7, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.19, "mb_s": 5060, "batch_ms_p50": 92.7, "batch_ms_p99": 103.3, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 55124, "direct_read_bytes": 939524096, "direct_write_bytes": 5930745856, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "kill9_during_store_meta_True", "passed": true, "utc": "02:27:43", "during": {"ok": 320, "miss": 52536, "wrong": 0, "verified": 0, "batches_failed": 6567, "hang": false, "seconds": 2.99, "mb_s": 1569, "batch_ms_p50": 1.2, "batch_ms_p99": 2.1, "wrong_ids": [], "errors": {"store failed for m@00000000@0@00000160: Connection refused (os error 111)": 7, "store failed for m@00000000@0@00000168: Connection refused (os error 111)": 5, "store failed for m@00000000@0@00000170: Connection refused (os error 111)": 7, "store failed for m@00000000@0@00000178: Connection refused (os error 111)": 6}}, "after": {"ok": 288, "miss": 3808, "wrong": 0, "verified": 288, "batches_failed": 476, "hang": false, "seconds": 3.75, "mb_s": 1126, "batch_ms_p50": 24.8, "batch_ms_p99": 134.1, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000120": 1, "load missed for m@00000000@0@00000129": 1, "load missed for m@00000000@0@00000136": 1, "load missed for m@00000000@0@0000013e": 1}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.15, "mb_s": 6068, "batch_ms_p50": 122.6, "batch_ms_p99": 150.7, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.18, "mb_s": 5092, "batch_ms_p50": 91.0, "batch_ms_p99": 97.8, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 52536, "direct_read_bytes": 5167382528, "direct_write_bytes": 6106906624, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_clean_wait0", "passed": true, "utc": "02:28:00", "stored": 256, "after": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5064, "batch_ms_p50": 107.0, "batch_ms_p99": 182.2, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.2, "mb_s": 4667, "batch_ms_p50": 180.0, "batch_ms_p99": 198.4, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.18, "mb_s": 5106, "batch_ms_p50": 89.0, "batch_ms_p99": 95.6, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5061, "batch_ms_p50": 110.1, "batch_ms_p99": 193.7, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 8455716864, "direct_write_bytes": 4697620480, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait0", "passed": true, "utc": "02:28:17", "stored": 256, "after": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5064, "batch_ms_p50": 109.3, "batch_ms_p99": 184.7, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.2, "mb_s": 4779, "batch_ms_p50": 175.3, "batch_ms_p99": 193.6, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.18, "mb_s": 5112, "batch_ms_p50": 90.2, "batch_ms_p99": 96.3, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5074, "batch_ms_p50": 106.3, "batch_ms_p99": 189.5, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 8455716864, "direct_write_bytes": 4697620480, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "restart_kill_wait3", "passed": true, "utc": "02:28:37", "stored": 256, "after": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5103, "batch_ms_p50": 107.5, "batch_ms_p99": 187.3, "wrong_ids": [], "errors": {}}, "new_data_store": {"ok": 64, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.2, "mb_s": 4662, "batch_ms_p50": 178.7, "batch_ms_p99": 198.5, "wrong_ids": [], "errors": {}, "first_try_failed": 0, "retry_ok": null}, "new_data_load": {"ok": 64, "miss": 0, "wrong": 0, "verified": 64, "batches_failed": 0, "hang": false, "seconds": 0.18, "mb_s": 5114, "batch_ms_p50": 89.7, "batch_ms_p99": 98.6, "wrong_ids": [], "errors": {}}, "after_new_data": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5073, "batch_ms_p50": 109.2, "batch_ms_p99": 187.5, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 8455716864, "direct_write_bytes": 4697620480, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap0", "passed": true, "utc": "02:29:01", "stored_b": 256, "load_a": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.4, "batch_ms_p99": 43.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000013": 1, "load missed for m@00000000@0@0000001b": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5047, "batch_ms_p50": 109.1, "batch_ms_p99": 189.8, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 4815, "batch_ms_p50": 192.8, "batch_ms_p99": 210.6, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5072, "batch_ms_p50": 105.5, "batch_ms_p99": 157.3, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.8, "batch_ms_p99": 44.2, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000002": 1, "load missed for m@00000000@0@0000000d": 1, "load missed for m@00000000@0@00000015": 1, "load missed for m@00000000@0@0000001f": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5067, "batch_ms_p50": 107.3, "batch_ms_p99": 184.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 11274289152, "direct_write_bytes": 11274289152, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace0_gap3", "passed": true, "utc": "02:29:29", "stored_b": 256, "load_a": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.7, "batch_ms_p99": 43.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@00000009": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001f": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.73, "mb_s": 5130, "batch_ms_p50": 105.9, "batch_ms_p99": 189.2, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.79, "mb_s": 4771, "batch_ms_p50": 194.1, "batch_ms_p99": 213.2, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5088, "batch_ms_p50": 103.7, "batch_ms_p99": 176.4, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.8, "batch_ms_p99": 43.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000006": 1, "load missed for m@00000000@0@0000000b": 1, "load missed for m@00000000@0@00000010": 1, "load missed for m@00000000@0@00000018": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5103, "batch_ms_p50": 101.6, "batch_ms_p99": 160.6, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 11274289152, "direct_write_bytes": 11274289152, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "stale_manifest_grace1_gap0", "passed": true, "utc": "02:29:54", "stored_b": 256, "load_a": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.8, "batch_ms_p99": 43.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000004": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001c": 1}}, "load_b": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5067, "batch_ms_p50": 107.8, "batch_ms_p99": 186.2, "wrong_ids": [], "errors": {}}, "store_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.78, "mb_s": 4833, "batch_ms_p50": 192.0, "batch_ms_p99": 208.9, "wrong_ids": [], "errors": {}}, "load_d": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.73, "mb_s": 5113, "batch_ms_p50": 106.5, "batch_ms_p99": 158.6, "wrong_ids": [], "errors": {}}, "load_a_again": {"ok": 0, "miss": 256, "wrong": 0, "verified": 0, "batches_failed": 32, "hang": false, "seconds": 0.2, "mb_s": 0, "batch_ms_p50": 24.5, "batch_ms_p99": 42.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000003": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000017": 1, "load missed for m@00000000@0@0000001f": 1}}, "load_b_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5059, "batch_ms_p50": 110.6, "batch_ms_p99": 189.2, "wrong_ids": [], "errors": {}}, "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 11274289152, "direct_write_bytes": 11274289152, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "corruption", "passed": true, "utc": "02:30:10", "one_block": {"ok": 255, "miss": 1, "wrong": 0, "verified": 255, "batches_failed": 1, "hang": false, "seconds": 0.74, "mb_s": 5050, "batch_ms_p50": 107.9, "batch_ms_p99": 186.3, "wrong_ids": [], "errors": {"load missed for m@00000000@0@0000000a": 1}}, "checksum_failures_one": 1, "one_gib": {"ok": 109, "miss": 147, "wrong": 0, "verified": 109, "batches_failed": 19, "hang": false, "seconds": 0.52, "mb_s": 3105, "batch_ms_p50": 72.5, "batch_ms_p99": 180.6, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000000": 1, "load missed for m@00000000@0@0000000a": 1, "load missed for m@00000000@0@00000016": 1, "load missed for m@00000000@0@00000019": 1}}, "checksum_failures_many": 147} +{"test": "corruption_repaired_by_new_store", "passed": true, "utc": "02:30:10", "store_again": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.45, "mb_s": 8311, "batch_ms_p50": 102.2, "batch_ms_p99": 203.2, "wrong_ids": [], "errors": {}}, "load_after": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5078, "batch_ms_p50": 110.0, "batch_ms_p99": 184.8, "wrong_ids": [], "errors": {}}} +{"test": "capacity_cap", "passed": true, "utc": "02:31:08", "store_rounds": [{"ok": 1146, "miss": 6, "wrong": 0, "verified": 0, "batches_failed": 5, "hang": false, "seconds": 5.38, "mb_s": 3125, "batch_ms_p50": 280.6, "batch_ms_p99": 496.8, "wrong_ids": [], "errors": {"store failed for m@00000000@0@000001bf: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/000001bf.kv' was not s": 1, "store failed for m@00000000@0@000002bf: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/000002bf.kv' was not s": 1, "store failed for m@00000000@0@000003cd: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/000003cd.kv' was not s": 1, "store failed for m@00000000@0@000003d7: commit_write failed: URI 'hypercache://kv_cache/t/m/0/0/_/000003d7.kv' was not s": 1}}, {"ok": 1152, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 3.99, "mb_s": 4235, "batch_ms_p50": 182.5, "batch_ms_p99": 398.2, "wrong_ids": [], "errors": {}}], "load_during": {"ok": 1404, "miss": 3044, "wrong": 0, "verified": 1404, "batches_failed": 433, "hang": false, "seconds": 10.48, "mb_s": 1967, "batch_ms_p50": 60.9, "batch_ms_p99": 412.4, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000004": 1, "load missed for m@00000000@0@00000009": 1, "load missed for m@00000000@0@00000013": 2, "load missed for m@00000000@0@00000026": 1}}, "load_quiet": {"ok": 292, "miss": 860, "wrong": 0, "verified": 292, "batches_failed": 109, "hang": false, "seconds": 1.51, "mb_s": 2830, "batch_ms_p50": 31.3, "batch_ms_p99": 136.9, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000003": 1, "load missed for m@00000000@0@0000000e": 1, "load missed for m@00000000@0@00000013": 1, "load missed for m@00000000@0@0000001d": 1}}, "store_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.43, "mb_s": 8827, "batch_ms_p50": 103.8, "batch_ms_p99": 110.1, "wrong_ids": [], "errors": {}}, "load_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.74, "mb_s": 5109, "batch_ms_p50": 108.5, "batch_ms_p99": 159.2, "wrong_ids": [], "errors": {}}, "evict_log_lines": "2275", "log_errors": "", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 6, "direct_read_bytes": 0, "direct_write_bytes": 37580963840, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} +{"test": "device_full_loop", "passed": true, "utc": "02:32:09", "store_rounds": [{"ok": 1152, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 7.18, "mb_s": 2356, "batch_ms_p50": 379.6, "batch_ms_p99": 635.8, "wrong_ids": [], "errors": {}}, {"ok": 1152, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 6.31, "mb_s": 2682, "batch_ms_p50": 346.2, "batch_ms_p99": 499.1, "wrong_ids": [], "errors": {}}], "load_during": {"ok": 2107, "miss": 2381, "wrong": 0, "verified": 2107, "batches_failed": 330, "hang": false, "seconds": 14.62, "mb_s": 2115, "batch_ms_p50": 136.8, "batch_ms_p99": 574.7, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000002": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000010": 2, "load missed for m@00000000@0@0000001f": 1}}, "load_quiet": {"ok": 292, "miss": 860, "wrong": 0, "verified": 292, "batches_failed": 108, "hang": false, "seconds": 1.61, "mb_s": 2659, "batch_ms_p50": 30.8, "batch_ms_p99": 206.6, "wrong_ids": [], "errors": {"load missed for m@00000000@0@00000001": 1, "load missed for m@00000000@0@0000000f": 1, "load missed for m@00000000@0@00000016": 1, "load missed for m@00000000@0@0000001e": 1}}, "store_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 0, "batches_failed": 0, "hang": false, "seconds": 0.72, "mb_s": 5215, "batch_ms_p50": 175.8, "batch_ms_p99": 222.2, "wrong_ids": [], "errors": {}}, "load_after_grace": {"ok": 256, "miss": 0, "wrong": 0, "verified": 256, "batches_failed": 0, "hang": false, "seconds": 0.83, "mb_s": 4514, "batch_ms_p50": 175.3, "batch_ms_p99": 212.1, "wrong_ids": [], "errors": {}}, "evict_log_lines": "2269", "log_errors": "", "stats": {"checksum_failures": 0, "load_failures": 0, "store_failures": 0, "direct_read_bytes": 0, "direct_write_bytes": 37580963840, "bounced_read_bytes": 0, "bounced_write_bytes": 0, "buffered_read_bytes": 0, "buffered_write_bytes": 0}} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-1.json new file mode 100644 index 0000000..4d3fe21 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.62, + "duration_min_ms": 2.44, + "duration_max_ms": 2.79, + "duration_p50_ms": 2.6, + "duration_p99_ms": 2.79, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 10720.36, + "throughput_min_mbps": 10021.22, + "throughput_max_mbps": 11455.11, + "ops_per_sec_avg": 49007.35, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.5, + "duration_min_ms": 0.48, + "duration_max_ms": 0.55, + "duration_p50_ms": 0.49, + "duration_p99_ms": 0.55, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 258111.69, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.44, + "duration_min_ms": 1.16, + "duration_max_ms": 1.63, + "duration_p50_ms": 1.45, + "duration_p99_ms": 1.63, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 19572.75, + "throughput_min_mbps": 17133.66, + "throughput_max_mbps": 24228.14, + "ops_per_sec_avg": 89475.42, + "latency_per_key_ms": 0.011 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-2.json new file mode 100644 index 0000000..465cf5e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.77, + "duration_min_ms": 2.67, + "duration_max_ms": 2.95, + "duration_p50_ms": 2.77, + "duration_p99_ms": 2.95, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 10096.68, + "throughput_min_mbps": 9482.11, + "throughput_max_mbps": 10494.26, + "ops_per_sec_avg": 46156.27, + "latency_per_key_ms": 0.022 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.45, + "duration_min_ms": 0.41, + "duration_max_ms": 0.5, + "duration_p50_ms": 0.45, + "duration_p99_ms": 0.5, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 286833.47, + "latency_per_key_ms": 0.003 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.36, + "duration_min_ms": 1.29, + "duration_max_ms": 1.46, + "duration_p50_ms": 1.35, + "duration_p99_ms": 1.46, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 20600.87, + "throughput_min_mbps": 19197.13, + "throughput_max_mbps": 21670.85, + "ops_per_sec_avg": 94175.39, + "latency_per_key_ms": 0.011 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-3.json new file mode 100644 index 0000000..8f882aa --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.75, + "duration_min_ms": 2.64, + "duration_max_ms": 2.86, + "duration_p50_ms": 2.75, + "duration_p99_ms": 2.86, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 10174.72, + "throughput_min_mbps": 9790.33, + "throughput_max_mbps": 10605.49, + "ops_per_sec_avg": 46512.98, + "latency_per_key_ms": 0.022 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.5, + "duration_min_ms": 0.47, + "duration_max_ms": 0.54, + "duration_p50_ms": 0.5, + "duration_p99_ms": 0.54, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 256840.37, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.42, + "duration_min_ms": 1.26, + "duration_max_ms": 1.83, + "duration_p50_ms": 1.41, + "duration_p99_ms": 1.83, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 19901.54, + "throughput_min_mbps": 15264.79, + "throughput_max_mbps": 22310.08, + "ops_per_sec_avg": 90978.45, + "latency_per_key_ms": 0.011 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-1.json new file mode 100644 index 0000000..af4108d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.74, + "duration_min_ms": 2.59, + "duration_max_ms": 2.99, + "duration_p50_ms": 2.75, + "duration_p99_ms": 2.99, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 10233.28, + "throughput_min_mbps": 9372.78, + "throughput_max_mbps": 10801.38, + "ops_per_sec_avg": 46780.69, + "latency_per_key_ms": 0.021 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.61, + "duration_min_ms": 0.58, + "duration_max_ms": 0.69, + "duration_p50_ms": 0.59, + "duration_p99_ms": 0.69, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 211642.39, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.27, + "duration_min_ms": 1.08, + "duration_max_ms": 1.69, + "duration_p50_ms": 1.2, + "duration_p99_ms": 1.69, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 22370.27, + "throughput_min_mbps": 16519.61, + "throughput_max_mbps": 25858.53, + "ops_per_sec_avg": 102264.11, + "latency_per_key_ms": 0.01 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-2.json new file mode 100644 index 0000000..986f63a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.58, + "duration_min_ms": 2.41, + "duration_max_ms": 2.84, + "duration_p50_ms": 2.54, + "duration_p99_ms": 2.84, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 10859.59, + "throughput_min_mbps": 9870.97, + "throughput_max_mbps": 11599.75, + "ops_per_sec_avg": 49643.85, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.6, + "duration_min_ms": 0.58, + "duration_max_ms": 0.69, + "duration_p50_ms": 0.6, + "duration_p99_ms": 0.69, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 212583.15, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.41, + "duration_min_ms": 1.3, + "duration_max_ms": 1.58, + "duration_p50_ms": 1.41, + "duration_p99_ms": 1.58, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 19906.01, + "throughput_min_mbps": 17740.1, + "throughput_max_mbps": 21586.17, + "ops_per_sec_avg": 90998.88, + "latency_per_key_ms": 0.011 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-3.json new file mode 100644 index 0000000..eda09b0 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.6, + "duration_min_ms": 2.45, + "duration_max_ms": 2.94, + "duration_p50_ms": 2.54, + "duration_p99_ms": 2.94, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 10801.2, + "throughput_min_mbps": 9534.68, + "throughput_max_mbps": 11434.96, + "ops_per_sec_avg": 49376.92, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.62, + "duration_min_ms": 0.59, + "duration_max_ms": 0.71, + "duration_p50_ms": 0.62, + "duration_p99_ms": 0.71, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 206111.66, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.35, + "duration_min_ms": 1.17, + "duration_max_ms": 2.12, + "duration_p50_ms": 1.34, + "duration_p99_ms": 2.12, + "duration_std_ms": 0.17, + "throughput_avg_mbps": 20920.75, + "throughput_min_mbps": 13232.98, + "throughput_max_mbps": 23941.28, + "ops_per_sec_avg": 95637.73, + "latency_per_key_ms": 0.011 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-1.json new file mode 100644 index 0000000..434161d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.22, + "duration_min_ms": 9.95, + "duration_max_ms": 10.48, + "duration_p50_ms": 10.24, + "duration_p99_ms": 10.48, + "duration_std_ms": 0.16, + "throughput_avg_mbps": 10960.68, + "throughput_min_mbps": 10682.45, + "throughput_max_mbps": 11259.04, + "ops_per_sec_avg": 50105.95, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 1.95, + "duration_min_ms": 1.71, + "duration_max_ms": 2.08, + "duration_p50_ms": 1.97, + "duration_p99_ms": 2.08, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 263372.56, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.42, + "duration_min_ms": 8.22, + "duration_max_ms": 11.11, + "duration_p50_ms": 9.38, + "duration_p99_ms": 11.11, + "duration_std_ms": 0.71, + "throughput_avg_mbps": 11959.64, + "throughput_min_mbps": 10083.71, + "throughput_max_mbps": 13617.08, + "ops_per_sec_avg": 54672.64, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-2.json new file mode 100644 index 0000000..b325f63 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.29, + "duration_min_ms": 9.96, + "duration_max_ms": 10.86, + "duration_p50_ms": 10.29, + "duration_p99_ms": 10.86, + "duration_std_ms": 0.2, + "throughput_avg_mbps": 10889.84, + "throughput_min_mbps": 10316.68, + "throughput_max_mbps": 11248.23, + "ops_per_sec_avg": 49782.11, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.08, + "duration_min_ms": 1.89, + "duration_max_ms": 2.71, + "duration_p50_ms": 2.03, + "duration_p99_ms": 2.71, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 248317.42, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.39, + "duration_min_ms": 8.31, + "duration_max_ms": 11.28, + "duration_p50_ms": 9.34, + "duration_p99_ms": 11.28, + "duration_std_ms": 0.72, + "throughput_avg_mbps": 11999.01, + "throughput_min_mbps": 9928.06, + "throughput_max_mbps": 13482.75, + "ops_per_sec_avg": 54852.62, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-3.json new file mode 100644 index 0000000..6c33cc8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.43, + "duration_min_ms": 10.1, + "duration_max_ms": 10.8, + "duration_p50_ms": 10.43, + "duration_p99_ms": 10.8, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 10741.55, + "throughput_min_mbps": 10375.12, + "throughput_max_mbps": 11089.23, + "ops_per_sec_avg": 49104.25, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 1.96, + "duration_min_ms": 1.88, + "duration_max_ms": 2.0, + "duration_p50_ms": 1.96, + "duration_p99_ms": 2.0, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 261778.1, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.2, + "duration_min_ms": 8.23, + "duration_max_ms": 10.96, + "duration_p50_ms": 9.36, + "duration_p99_ms": 10.96, + "duration_std_ms": 0.73, + "throughput_avg_mbps": 12242.4, + "throughput_min_mbps": 10221.68, + "throughput_max_mbps": 13608.79, + "ops_per_sec_avg": 55965.25, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-1.json new file mode 100644 index 0000000..72f3bef --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.18, + "duration_min_ms": 9.93, + "duration_max_ms": 10.57, + "duration_p50_ms": 10.11, + "duration_p99_ms": 10.57, + "duration_std_ms": 0.17, + "throughput_avg_mbps": 11009.13, + "throughput_min_mbps": 10595.93, + "throughput_max_mbps": 11281.22, + "ops_per_sec_avg": 50327.44, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.48, + "duration_min_ms": 2.36, + "duration_max_ms": 2.71, + "duration_p50_ms": 2.43, + "duration_p99_ms": 2.71, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 206860.96, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.32, + "duration_min_ms": 8.35, + "duration_max_ms": 10.52, + "duration_p50_ms": 9.32, + "duration_p99_ms": 10.52, + "duration_std_ms": 0.58, + "throughput_avg_mbps": 12065.25, + "throughput_min_mbps": 10649.67, + "throughput_max_mbps": 13415.77, + "ops_per_sec_avg": 55155.41, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-2.json new file mode 100644 index 0000000..f5a4593 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.4, + "duration_min_ms": 10.12, + "duration_max_ms": 10.85, + "duration_p50_ms": 10.35, + "duration_p99_ms": 10.85, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 10773.42, + "throughput_min_mbps": 10324.84, + "throughput_max_mbps": 11071.42, + "ops_per_sec_avg": 49249.91, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.32, + "duration_min_ms": 2.1, + "duration_max_ms": 2.58, + "duration_p50_ms": 2.27, + "duration_p99_ms": 2.58, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 221772.36, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.27, + "duration_min_ms": 8.33, + "duration_max_ms": 10.94, + "duration_p50_ms": 9.39, + "duration_p99_ms": 10.94, + "duration_std_ms": 0.73, + "throughput_avg_mbps": 12154.78, + "throughput_min_mbps": 10234.01, + "throughput_max_mbps": 13449.47, + "ops_per_sec_avg": 55564.71, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-3.json new file mode 100644 index 0000000..0d35b75 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/fs_native-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"fs_native\",\"base_path\":\"/dev/shm/lp/run/fs\",\"num_workers\":8,\"use_odirect\":false}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 10.4, + "duration_min_ms": 10.02, + "duration_max_ms": 10.85, + "duration_p50_ms": 10.36, + "duration_p99_ms": 10.85, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 10773.74, + "throughput_min_mbps": 10325.47, + "throughput_max_mbps": 11174.49, + "ops_per_sec_avg": 49251.37, + "latency_per_key_ms": 0.02 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.55, + "duration_min_ms": 2.43, + "duration_max_ms": 2.87, + "duration_p50_ms": 2.56, + "duration_p99_ms": 2.87, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 201288.18, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.41, + "duration_min_ms": 8.29, + "duration_max_ms": 11.53, + "duration_p50_ms": 9.44, + "duration_p99_ms": 11.53, + "duration_std_ms": 0.92, + "throughput_avg_mbps": 12011.89, + "throughput_min_mbps": 9711.7, + "throughput_max_mbps": 13513.36, + "ops_per_sec_avg": 54911.51, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-1.json new file mode 100644 index 0000000..6c60035 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.16, + "duration_min_ms": 10.76, + "duration_max_ms": 11.53, + "duration_p50_ms": 11.1, + "duration_p99_ms": 11.53, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 2508.72, + "throughput_min_mbps": 2427.65, + "throughput_max_mbps": 2603.36, + "ops_per_sec_avg": 11468.42, + "latency_per_key_ms": 0.087 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.52, + "duration_max_ms": 0.54, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.54, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 243345.96, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.94, + "duration_min_ms": 2.78, + "duration_max_ms": 3.06, + "duration_p50_ms": 2.93, + "duration_p99_ms": 3.06, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 9527.98, + "throughput_min_mbps": 9143.41, + "throughput_max_mbps": 10071.75, + "ops_per_sec_avg": 43556.46, + "latency_per_key_ms": 0.023 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-2.json new file mode 100644 index 0000000..9bffe43 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.25, + "duration_min_ms": 10.93, + "duration_max_ms": 11.75, + "duration_p50_ms": 11.21, + "duration_p99_ms": 11.75, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2489.18, + "throughput_min_mbps": 2383.5, + "throughput_max_mbps": 2562.3, + "ops_per_sec_avg": 11379.11, + "latency_per_key_ms": 0.088 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.52, + "duration_max_ms": 0.55, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.55, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 243524.06, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 3.09, + "duration_min_ms": 2.95, + "duration_max_ms": 3.27, + "duration_p50_ms": 3.07, + "duration_p99_ms": 3.27, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 9079.11, + "throughput_min_mbps": 8559.51, + "throughput_max_mbps": 9491.58, + "ops_per_sec_avg": 41504.5, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-3.json new file mode 100644 index 0000000..81183b9 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.14, + "duration_min_ms": 10.81, + "duration_max_ms": 11.63, + "duration_p50_ms": 11.1, + "duration_p99_ms": 11.63, + "duration_std_ms": 0.19, + "throughput_avg_mbps": 2514.97, + "throughput_min_mbps": 2407.68, + "throughput_max_mbps": 2589.84, + "ops_per_sec_avg": 11497.01, + "latency_per_key_ms": 0.087 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.52, + "duration_min_ms": 0.51, + "duration_max_ms": 0.53, + "duration_p50_ms": 0.52, + "duration_p99_ms": 0.53, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 247654.51, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 3.11, + "duration_min_ms": 3.0, + "duration_max_ms": 3.28, + "duration_p50_ms": 3.12, + "duration_p99_ms": 3.28, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 8996.1, + "throughput_min_mbps": 8548.02, + "throughput_max_mbps": 9327.3, + "ops_per_sec_avg": 41125.04, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-1.json new file mode 100644 index 0000000..bb24204 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.16, + "duration_min_ms": 10.59, + "duration_max_ms": 11.79, + "duration_p50_ms": 11.12, + "duration_p99_ms": 11.79, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 2510.38, + "throughput_min_mbps": 2375.2, + "throughput_max_mbps": 2643.63, + "ops_per_sec_avg": 11476.04, + "latency_per_key_ms": 0.087 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.57, + "duration_min_ms": 0.55, + "duration_max_ms": 0.62, + "duration_p50_ms": 0.56, + "duration_p99_ms": 0.62, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 226100.59, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 3.07, + "duration_min_ms": 2.93, + "duration_max_ms": 3.54, + "duration_p50_ms": 3.05, + "duration_p99_ms": 3.54, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 9122.57, + "throughput_min_mbps": 7917.24, + "throughput_max_mbps": 9562.12, + "ops_per_sec_avg": 41703.16, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-2.json new file mode 100644 index 0000000..305d9ec --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.15, + "duration_min_ms": 10.71, + "duration_max_ms": 11.78, + "duration_p50_ms": 11.14, + "duration_p99_ms": 11.78, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 2513.37, + "throughput_min_mbps": 2376.14, + "throughput_max_mbps": 2614.49, + "ops_per_sec_avg": 11489.7, + "latency_per_key_ms": 0.087 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.57, + "duration_min_ms": 0.55, + "duration_max_ms": 0.62, + "duration_p50_ms": 0.56, + "duration_p99_ms": 0.62, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 226194.08, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 3.1, + "duration_min_ms": 2.94, + "duration_max_ms": 3.23, + "duration_p50_ms": 3.1, + "duration_p99_ms": 3.23, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 9043.3, + "throughput_min_mbps": 8667.44, + "throughput_max_mbps": 9525.52, + "ops_per_sec_avg": 41340.82, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-3.json new file mode 100644 index 0000000..add505b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.15, + "duration_min_ms": 10.66, + "duration_max_ms": 11.67, + "duration_p50_ms": 11.18, + "duration_p99_ms": 11.67, + "duration_std_ms": 0.24, + "throughput_avg_mbps": 2511.66, + "throughput_min_mbps": 2400.15, + "throughput_max_mbps": 2626.99, + "ops_per_sec_avg": 11481.86, + "latency_per_key_ms": 0.087 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.56, + "duration_min_ms": 0.55, + "duration_max_ms": 0.62, + "duration_p50_ms": 0.55, + "duration_p99_ms": 0.62, + "duration_std_ms": 0.01, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 229774.51, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 3.08, + "duration_min_ms": 2.92, + "duration_max_ms": 3.16, + "duration_p50_ms": 3.07, + "duration_p99_ms": 3.16, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 9103.78, + "throughput_min_mbps": 8871.91, + "throughput_max_mbps": 9585.2, + "ops_per_sec_avg": 41617.27, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-1.json new file mode 100644 index 0000000..3d9b1d2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.97, + "duration_min_ms": 42.99, + "duration_max_ms": 138.38, + "duration_p50_ms": 43.81, + "duration_p99_ms": 138.38, + "duration_std_ms": 17.27, + "throughput_avg_mbps": 2497.78, + "throughput_min_mbps": 809.35, + "throughput_max_mbps": 2605.09, + "ops_per_sec_avg": 11418.41, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.03, + "duration_min_ms": 1.98, + "duration_max_ms": 2.21, + "duration_p50_ms": 2.0, + "duration_p99_ms": 2.21, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 252318.15, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.24, + "duration_min_ms": 13.79, + "duration_max_ms": 14.51, + "duration_p50_ms": 14.24, + "duration_p99_ms": 14.51, + "duration_std_ms": 0.15, + "throughput_avg_mbps": 7863.28, + "throughput_min_mbps": 7720.42, + "throughput_max_mbps": 8120.88, + "ops_per_sec_avg": 35946.44, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-2.json new file mode 100644 index 0000000..3fe2d36 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.22, + "duration_min_ms": 43.36, + "duration_max_ms": 139.16, + "duration_p50_ms": 43.93, + "duration_p99_ms": 139.16, + "duration_std_ms": 17.37, + "throughput_avg_mbps": 2485.14, + "throughput_min_mbps": 804.82, + "throughput_max_mbps": 2583.21, + "ops_per_sec_avg": 11360.65, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.03, + "duration_min_ms": 1.98, + "duration_max_ms": 2.2, + "duration_p50_ms": 2.0, + "duration_p99_ms": 2.2, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 252987.37, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.21, + "duration_min_ms": 13.87, + "duration_max_ms": 14.55, + "duration_p50_ms": 14.24, + "duration_p99_ms": 14.55, + "duration_std_ms": 0.15, + "throughput_avg_mbps": 7881.38, + "throughput_min_mbps": 7700.19, + "throughput_max_mbps": 8075.24, + "ops_per_sec_avg": 36029.15, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-3.json new file mode 100644 index 0000000..a2573e5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.07, + "duration_min_ms": 43.12, + "duration_max_ms": 137.71, + "duration_p50_ms": 43.82, + "duration_p99_ms": 137.71, + "duration_std_ms": 17.13, + "throughput_avg_mbps": 2491.12, + "throughput_min_mbps": 813.31, + "throughput_max_mbps": 2597.46, + "ops_per_sec_avg": 11387.97, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.03, + "duration_min_ms": 1.97, + "duration_max_ms": 2.3, + "duration_p50_ms": 1.99, + "duration_p99_ms": 2.3, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 252638.41, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.16, + "duration_min_ms": 13.85, + "duration_max_ms": 14.43, + "duration_p50_ms": 14.17, + "duration_p99_ms": 14.43, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 7907.57, + "throughput_min_mbps": 7762.24, + "throughput_max_mbps": 8085.39, + "ops_per_sec_avg": 36148.9, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-1.json new file mode 100644 index 0000000..591bc46 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.36, + "duration_min_ms": 43.37, + "duration_max_ms": 139.63, + "duration_p50_ms": 44.08, + "duration_p99_ms": 139.63, + "duration_std_ms": 17.44, + "throughput_avg_mbps": 2477.73, + "throughput_min_mbps": 802.1, + "throughput_max_mbps": 2582.38, + "ops_per_sec_avg": 11326.77, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.22, + "duration_min_ms": 2.1, + "duration_max_ms": 2.39, + "duration_p50_ms": 2.18, + "duration_p99_ms": 2.39, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 230851.82, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.22, + "duration_min_ms": 13.92, + "duration_max_ms": 14.55, + "duration_p50_ms": 14.22, + "duration_p99_ms": 14.55, + "duration_std_ms": 0.16, + "throughput_avg_mbps": 7879.69, + "throughput_min_mbps": 7699.9, + "throughput_max_mbps": 8045.7, + "ops_per_sec_avg": 36021.45, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-2.json new file mode 100644 index 0000000..ecec22d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.27, + "duration_min_ms": 43.49, + "duration_max_ms": 137.02, + "duration_p50_ms": 44.12, + "duration_p99_ms": 137.02, + "duration_std_ms": 16.96, + "throughput_avg_mbps": 2478.57, + "throughput_min_mbps": 817.39, + "throughput_max_mbps": 2575.26, + "ops_per_sec_avg": 11330.61, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.26, + "duration_min_ms": 2.11, + "duration_max_ms": 2.42, + "duration_p50_ms": 2.22, + "duration_p99_ms": 2.42, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 226963.73, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.12, + "duration_min_ms": 13.7, + "duration_max_ms": 14.35, + "duration_p50_ms": 14.12, + "duration_p99_ms": 14.35, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 7935.7, + "throughput_min_mbps": 7802.83, + "throughput_max_mbps": 8176.32, + "ops_per_sec_avg": 36277.49, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-3.json new file mode 100644 index 0000000..805514d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/raw_block-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"raw_block\",\"device_path\":\"/dev/shm/lp/run/rb.img\",\"slot_bytes\":233472,\"capacity_bytes\":1099511627776,\"load_checkpoint_on_init\":false,\"meta_enable_periodic\":false,\"num_store_workers\":8,\"num_load_workers\":8,\"io_engine\":\"posix\"}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.1, + "duration_min_ms": 42.88, + "duration_max_ms": 138.27, + "duration_p50_ms": 43.88, + "duration_p99_ms": 138.27, + "duration_std_ms": 17.23, + "throughput_avg_mbps": 2490.87, + "throughput_min_mbps": 810.0, + "throughput_max_mbps": 2611.83, + "ops_per_sec_avg": 11386.83, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 2.32, + "duration_min_ms": 2.14, + "duration_max_ms": 2.65, + "duration_p50_ms": 2.35, + "duration_p99_ms": 2.65, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 220854.09, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 14.2, + "duration_min_ms": 13.92, + "duration_max_ms": 14.64, + "duration_p50_ms": 14.17, + "duration_p99_ms": 14.64, + "duration_std_ms": 0.14, + "throughput_avg_mbps": 7890.41, + "throughput_min_mbps": 7649.04, + "throughput_max_mbps": 8048.23, + "ops_per_sec_avg": 36070.44, + "latency_per_key_ms": 0.028 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-1.json new file mode 100644 index 0000000..b7a858f --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.7, + "duration_min_ms": 11.3, + "duration_max_ms": 12.08, + "duration_p50_ms": 11.67, + "duration_p99_ms": 12.08, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2394.15, + "throughput_min_mbps": 2318.05, + "throughput_max_mbps": 2477.76, + "ops_per_sec_avg": 10944.68, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.61, + "duration_min_ms": 0.56, + "duration_max_ms": 0.67, + "duration_p50_ms": 0.6, + "duration_p99_ms": 0.67, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 210109.27, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.9, + "duration_min_ms": 1.78, + "duration_max_ms": 2.13, + "duration_p50_ms": 1.87, + "duration_p99_ms": 2.13, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 14737.99, + "throughput_min_mbps": 13116.96, + "throughput_max_mbps": 15727.55, + "ops_per_sec_avg": 67373.66, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-2.json new file mode 100644 index 0000000..d6a46f8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.75, + "duration_min_ms": 11.52, + "duration_max_ms": 12.47, + "duration_p50_ms": 11.69, + "duration_p99_ms": 12.47, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2384.02, + "throughput_min_mbps": 2244.7, + "throughput_max_mbps": 2431.42, + "ops_per_sec_avg": 10898.4, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.53, + "duration_min_ms": 0.44, + "duration_max_ms": 0.64, + "duration_p50_ms": 0.5, + "duration_p99_ms": 0.64, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 244953.77, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.89, + "duration_min_ms": 1.68, + "duration_max_ms": 2.14, + "duration_p50_ms": 1.88, + "duration_p99_ms": 2.14, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 14883.95, + "throughput_min_mbps": 13095.26, + "throughput_max_mbps": 16714.85, + "ops_per_sec_avg": 68040.9, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-3.json new file mode 100644 index 0000000..621e139 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.85, + "duration_min_ms": 11.57, + "duration_max_ms": 12.55, + "duration_p50_ms": 11.83, + "duration_p99_ms": 12.55, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2363.08, + "throughput_min_mbps": 2230.98, + "throughput_max_mbps": 2419.19, + "ops_per_sec_avg": 10802.65, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.6, + "duration_min_ms": 0.46, + "duration_max_ms": 0.64, + "duration_p50_ms": 0.62, + "duration_p99_ms": 0.64, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 213963.25, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.98, + "duration_min_ms": 1.8, + "duration_max_ms": 2.26, + "duration_p50_ms": 1.97, + "duration_p99_ms": 2.26, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14204.22, + "throughput_min_mbps": 12413.06, + "throughput_max_mbps": 15532.02, + "ops_per_sec_avg": 64933.57, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-1.json new file mode 100644 index 0000000..9cecc3a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.67, + "duration_min_ms": 11.37, + "duration_max_ms": 12.23, + "duration_p50_ms": 11.62, + "duration_p99_ms": 12.23, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2400.89, + "throughput_min_mbps": 2289.89, + "throughput_max_mbps": 2463.25, + "ops_per_sec_avg": 10975.48, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.84, + "duration_min_ms": 0.72, + "duration_max_ms": 0.9, + "duration_p50_ms": 0.85, + "duration_p99_ms": 0.9, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 153578.74, + "latency_per_key_ms": 0.007, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.92, + "duration_min_ms": 1.7, + "duration_max_ms": 2.14, + "duration_p50_ms": 1.9, + "duration_p99_ms": 2.14, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14607.17, + "throughput_min_mbps": 13100.67, + "throughput_max_mbps": 16443.89, + "ops_per_sec_avg": 66775.65, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-2.json new file mode 100644 index 0000000..a930f65 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.8, + "duration_min_ms": 11.53, + "duration_max_ms": 12.53, + "duration_p50_ms": 11.74, + "duration_p99_ms": 12.53, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2373.27, + "throughput_min_mbps": 2234.14, + "throughput_max_mbps": 2428.28, + "ops_per_sec_avg": 10849.21, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.92, + "duration_min_ms": 0.7, + "duration_max_ms": 1.11, + "duration_p50_ms": 0.88, + "duration_p99_ms": 1.11, + "duration_std_ms": 0.15, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 142996.34, + "latency_per_key_ms": 0.007, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.96, + "duration_min_ms": 1.81, + "duration_max_ms": 2.32, + "duration_p50_ms": 1.92, + "duration_p99_ms": 2.32, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 14316.72, + "throughput_min_mbps": 12082.58, + "throughput_max_mbps": 15436.97, + "ops_per_sec_avg": 65447.87, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-3.json new file mode 100644 index 0000000..2d8995e --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.86, + "duration_min_ms": 11.4, + "duration_max_ms": 12.52, + "duration_p50_ms": 11.8, + "duration_p99_ms": 12.52, + "duration_std_ms": 0.28, + "throughput_avg_mbps": 2363.1, + "throughput_min_mbps": 2235.68, + "throughput_max_mbps": 2455.77, + "ops_per_sec_avg": 10802.76, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.7, + "duration_min_ms": 0.58, + "duration_max_ms": 0.89, + "duration_p50_ms": 0.68, + "duration_p99_ms": 0.89, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 185059.28, + "latency_per_key_ms": 0.005, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.98, + "duration_min_ms": 1.82, + "duration_max_ms": 2.22, + "duration_p50_ms": 1.97, + "duration_p99_ms": 2.22, + "duration_std_ms": 0.07, + "throughput_avg_mbps": 14189.21, + "throughput_min_mbps": 12616.93, + "throughput_max_mbps": 15381.07, + "ops_per_sec_avg": 64864.96, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-1.json new file mode 100644 index 0000000..1141d9a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.58, + "duration_min_ms": 45.94, + "duration_max_ms": 49.7, + "duration_p50_ms": 46.34, + "duration_p99_ms": 49.7, + "duration_std_ms": 0.71, + "throughput_avg_mbps": 2405.09, + "throughput_min_mbps": 2253.34, + "throughput_max_mbps": 2437.86, + "ops_per_sec_avg": 10994.72, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.51, + "duration_min_ms": 2.22, + "duration_max_ms": 2.87, + "duration_p50_ms": 2.47, + "duration_p99_ms": 2.87, + "duration_std_ms": 0.19, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 205382.27, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.3, + "duration_min_ms": 8.95, + "duration_max_ms": 95.21, + "duration_p50_ms": 9.23, + "duration_p99_ms": 95.21, + "duration_std_ms": 15.67, + "throughput_avg_mbps": 11534.58, + "throughput_min_mbps": 1176.34, + "throughput_max_mbps": 12515.08, + "ops_per_sec_avg": 52729.52, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-2.json new file mode 100644 index 0000000..9a5cf86 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.89, + "duration_min_ms": 46.17, + "duration_max_ms": 49.68, + "duration_p50_ms": 46.78, + "duration_p99_ms": 49.68, + "duration_std_ms": 0.66, + "throughput_avg_mbps": 2388.76, + "throughput_min_mbps": 2254.57, + "throughput_max_mbps": 2425.8, + "ops_per_sec_avg": 10920.06, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.19, + "duration_min_ms": 1.69, + "duration_max_ms": 2.47, + "duration_p50_ms": 2.16, + "duration_p99_ms": 2.47, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 235824.35, + "latency_per_key_ms": 0.004 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.47, + "duration_min_ms": 9.19, + "duration_max_ms": 95.05, + "duration_p50_ms": 9.5, + "duration_p99_ms": 95.05, + "duration_std_ms": 15.6, + "throughput_avg_mbps": 11306.32, + "throughput_min_mbps": 1178.33, + "throughput_max_mbps": 12191.28, + "ops_per_sec_avg": 51686.01, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-3.json new file mode 100644 index 0000000..6ead337 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.78, + "duration_min_ms": 45.93, + "duration_max_ms": 49.46, + "duration_p50_ms": 46.68, + "duration_p99_ms": 49.46, + "duration_std_ms": 0.62, + "throughput_avg_mbps": 2394.46, + "throughput_min_mbps": 2264.61, + "throughput_max_mbps": 2438.76, + "ops_per_sec_avg": 10946.12, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 2.79, + "duration_min_ms": 2.06, + "duration_max_ms": 3.95, + "duration_p50_ms": 2.74, + "duration_p99_ms": 3.95, + "duration_std_ms": 0.47, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 188691.95, + "latency_per_key_ms": 0.005 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.3, + "duration_min_ms": 9.11, + "duration_max_ms": 95.72, + "duration_p50_ms": 9.34, + "duration_p99_ms": 95.72, + "duration_std_ms": 15.76, + "throughput_avg_mbps": 11543.29, + "throughput_min_mbps": 1170.08, + "throughput_max_mbps": 12289.71, + "ops_per_sec_avg": 52769.31, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-1.json new file mode 100644 index 0000000..50c50ed --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.89, + "duration_min_ms": 46.2, + "duration_max_ms": 49.49, + "duration_p50_ms": 46.7, + "duration_p99_ms": 49.49, + "duration_std_ms": 0.7, + "throughput_avg_mbps": 2389.16, + "throughput_min_mbps": 2262.9, + "throughput_max_mbps": 2424.5, + "ops_per_sec_avg": 10921.88, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 6.13, + "duration_min_ms": 2.96, + "duration_max_ms": 86.88, + "duration_p50_ms": 3.31, + "duration_p99_ms": 86.88, + "duration_std_ms": 15.25, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 148890.12, + "latency_per_key_ms": 0.012, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.47, + "duration_min_ms": 9.15, + "duration_max_ms": 10.51, + "duration_p50_ms": 9.36, + "duration_p99_ms": 10.51, + "duration_std_ms": 0.3, + "throughput_avg_mbps": 11840.36, + "throughput_min_mbps": 10651.83, + "throughput_max_mbps": 12236.04, + "ops_per_sec_avg": 54127.35, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-2.json new file mode 100644 index 0000000..c845ac5 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.94, + "duration_min_ms": 46.08, + "duration_max_ms": 49.59, + "duration_p50_ms": 46.77, + "duration_p99_ms": 49.59, + "duration_std_ms": 0.69, + "throughput_avg_mbps": 2386.6, + "throughput_min_mbps": 2258.37, + "throughput_max_mbps": 2430.55, + "ops_per_sec_avg": 10910.16, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 5.86, + "duration_min_ms": 2.71, + "duration_max_ms": 85.9, + "duration_p50_ms": 3.12, + "duration_p99_ms": 85.9, + "duration_std_ms": 15.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 160301.76, + "latency_per_key_ms": 0.011, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.5, + "duration_min_ms": 9.15, + "duration_max_ms": 10.53, + "duration_p50_ms": 9.35, + "duration_p99_ms": 10.53, + "duration_std_ms": 0.4, + "throughput_avg_mbps": 11806.7, + "throughput_min_mbps": 10638.87, + "throughput_max_mbps": 12237.86, + "ops_per_sec_avg": 53973.49, + "latency_per_key_ms": 0.019 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-3.json new file mode 100644 index 0000000..af5bab6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_batch-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.18, + "duration_min_ms": 46.44, + "duration_max_ms": 50.33, + "duration_p50_ms": 46.92, + "duration_p99_ms": 50.33, + "duration_std_ms": 0.78, + "throughput_avg_mbps": 2374.39, + "throughput_min_mbps": 2225.44, + "throughput_max_mbps": 2411.75, + "ops_per_sec_avg": 10854.34, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 5.8, + "duration_min_ms": 2.55, + "duration_max_ms": 87.7, + "duration_p50_ms": 3.0, + "duration_p99_ms": 87.7, + "duration_std_ms": 15.47, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 167602.82, + "latency_per_key_ms": 0.011, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.63, + "duration_min_ms": 9.09, + "duration_max_ms": 12.15, + "duration_p50_ms": 9.44, + "duration_p99_ms": 12.15, + "duration_std_ms": 0.61, + "throughput_avg_mbps": 11672.31, + "throughput_min_mbps": 9218.97, + "throughput_max_mbps": 12326.92, + "ops_per_sec_avg": 53359.12, + "latency_per_key_ms": 0.019 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-1.json new file mode 100644 index 0000000..1fcf289 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.78, + "duration_min_ms": 11.43, + "duration_max_ms": 12.59, + "duration_p50_ms": 11.74, + "duration_p99_ms": 12.59, + "duration_std_ms": 0.27, + "throughput_avg_mbps": 2377.92, + "throughput_min_mbps": 2223.19, + "throughput_max_mbps": 2449.56, + "ops_per_sec_avg": 10870.47, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 1.03, + "duration_min_ms": 0.95, + "duration_max_ms": 1.17, + "duration_p50_ms": 1.02, + "duration_p99_ms": 1.17, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 124703.79, + "latency_per_key_ms": 0.008 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.84, + "duration_min_ms": 1.68, + "duration_max_ms": 2.35, + "duration_p50_ms": 1.82, + "duration_p99_ms": 2.35, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 15281.57, + "throughput_min_mbps": 11903.5, + "throughput_max_mbps": 16675.14, + "ops_per_sec_avg": 69858.6, + "latency_per_key_ms": 0.014 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-2.json new file mode 100644 index 0000000..0643575 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.72, + "duration_min_ms": 11.49, + "duration_max_ms": 12.27, + "duration_p50_ms": 11.69, + "duration_p99_ms": 12.27, + "duration_std_ms": 0.18, + "throughput_avg_mbps": 2389.26, + "throughput_min_mbps": 2281.68, + "throughput_max_mbps": 2436.5, + "ops_per_sec_avg": 10922.33, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 1.25, + "duration_min_ms": 1.13, + "duration_max_ms": 1.34, + "duration_p50_ms": 1.26, + "duration_p99_ms": 1.34, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 102396.59, + "latency_per_key_ms": 0.01 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.95, + "duration_min_ms": 1.77, + "duration_max_ms": 2.38, + "duration_p50_ms": 1.95, + "duration_p99_ms": 2.38, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14376.6, + "throughput_min_mbps": 11751.83, + "throughput_max_mbps": 15839.59, + "ops_per_sec_avg": 65721.61, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-3.json new file mode 100644 index 0000000..8189791 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.9, + "duration_min_ms": 11.61, + "duration_max_ms": 12.6, + "duration_p50_ms": 11.83, + "duration_p99_ms": 12.6, + "duration_std_ms": 0.24, + "throughput_avg_mbps": 2354.11, + "throughput_min_mbps": 2222.8, + "throughput_max_mbps": 2411.24, + "ops_per_sec_avg": 10761.65, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 1.27, + "duration_min_ms": 0.97, + "duration_max_ms": 1.4, + "duration_p50_ms": 1.35, + "duration_p99_ms": 1.4, + "duration_std_ms": 0.17, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 102900.28, + "latency_per_key_ms": 0.01 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.93, + "duration_min_ms": 1.76, + "duration_max_ms": 2.13, + "duration_p50_ms": 1.92, + "duration_p99_ms": 2.13, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14537.09, + "throughput_min_mbps": 13133.05, + "throughput_max_mbps": 15864.68, + "ops_per_sec_avg": 66455.27, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-1.json new file mode 100644 index 0000000..769e1cd --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.71, + "duration_min_ms": 11.37, + "duration_max_ms": 12.23, + "duration_p50_ms": 11.66, + "duration_p99_ms": 12.23, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2390.92, + "throughput_min_mbps": 2288.7, + "throughput_max_mbps": 2461.86, + "ops_per_sec_avg": 10929.92, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.29, + "duration_min_ms": 1.17, + "duration_max_ms": 1.39, + "duration_p50_ms": 1.28, + "duration_p99_ms": 1.39, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 99161.73, + "latency_per_key_ms": 0.01, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.86, + "duration_min_ms": 1.66, + "duration_max_ms": 2.26, + "duration_p50_ms": 1.84, + "duration_p99_ms": 2.26, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 15116.8, + "throughput_min_mbps": 12413.56, + "throughput_max_mbps": 16818.86, + "ops_per_sec_avg": 69105.36, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-2.json new file mode 100644 index 0000000..dd5e358 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.77, + "duration_min_ms": 11.46, + "duration_max_ms": 12.19, + "duration_p50_ms": 11.72, + "duration_p99_ms": 12.19, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2380.54, + "throughput_min_mbps": 2296.38, + "throughput_max_mbps": 2443.12, + "ops_per_sec_avg": 10882.45, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.52, + "duration_min_ms": 1.39, + "duration_max_ms": 1.69, + "duration_p50_ms": 1.52, + "duration_p99_ms": 1.69, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 84550.26, + "latency_per_key_ms": 0.012, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.93, + "duration_min_ms": 1.69, + "duration_max_ms": 2.3, + "duration_p50_ms": 1.92, + "duration_p99_ms": 2.3, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 14602.43, + "throughput_min_mbps": 12174.65, + "throughput_max_mbps": 16605.8, + "ops_per_sec_avg": 66753.97, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-3.json new file mode 100644 index 0000000..ce04c38 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.91, + "duration_min_ms": 11.55, + "duration_max_ms": 12.51, + "duration_p50_ms": 11.87, + "duration_p99_ms": 12.51, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2352.36, + "throughput_min_mbps": 2238.65, + "throughput_max_mbps": 2424.89, + "ops_per_sec_avg": 10753.65, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.47, + "duration_min_ms": 1.38, + "duration_max_ms": 1.56, + "duration_p50_ms": 1.48, + "duration_p99_ms": 1.56, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 86975.07, + "latency_per_key_ms": 0.012, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.94, + "duration_min_ms": 1.74, + "duration_max_ms": 2.41, + "duration_p50_ms": 1.92, + "duration_p99_ms": 2.41, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 14507.76, + "throughput_min_mbps": 11624.16, + "throughput_max_mbps": 16122.69, + "ops_per_sec_avg": 66321.19, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-1.json new file mode 100644 index 0000000..1a6ea5b --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.42, + "duration_min_ms": 45.66, + "duration_max_ms": 49.75, + "duration_p50_ms": 46.21, + "duration_p99_ms": 49.75, + "duration_std_ms": 0.72, + "throughput_avg_mbps": 2413.22, + "throughput_min_mbps": 2251.14, + "throughput_max_mbps": 2452.92, + "ops_per_sec_avg": 11031.84, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 4.99, + "duration_min_ms": 4.07, + "duration_max_ms": 5.53, + "duration_p50_ms": 5.0, + "duration_p99_ms": 5.53, + "duration_std_ms": 0.34, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 103166.94, + "latency_per_key_ms": 0.01 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.18, + "duration_min_ms": 8.88, + "duration_max_ms": 95.65, + "duration_p50_ms": 9.16, + "duration_p99_ms": 95.65, + "duration_std_ms": 15.77, + "throughput_avg_mbps": 11701.74, + "throughput_min_mbps": 1170.9, + "throughput_max_mbps": 12608.4, + "ops_per_sec_avg": 53493.68, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-2.json new file mode 100644 index 0000000..30a4cf6 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.7, + "duration_min_ms": 46.24, + "duration_max_ms": 49.41, + "duration_p50_ms": 46.58, + "duration_p99_ms": 49.41, + "duration_std_ms": 0.59, + "throughput_avg_mbps": 2398.47, + "throughput_min_mbps": 2266.87, + "throughput_max_mbps": 2422.23, + "ops_per_sec_avg": 10964.44, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 4.75, + "duration_min_ms": 3.92, + "duration_max_ms": 5.58, + "duration_p50_ms": 4.72, + "duration_p99_ms": 5.58, + "duration_std_ms": 0.38, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 108558.42, + "latency_per_key_ms": 0.009 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.16, + "duration_min_ms": 8.91, + "duration_max_ms": 94.09, + "duration_p50_ms": 9.26, + "duration_p99_ms": 94.09, + "duration_std_ms": 15.48, + "throughput_avg_mbps": 11646.95, + "throughput_min_mbps": 1190.41, + "throughput_max_mbps": 12570.74, + "ops_per_sec_avg": 53243.21, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-3.json new file mode 100644 index 0000000..3def607 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.07, + "duration_min_ms": 46.35, + "duration_max_ms": 49.84, + "duration_p50_ms": 46.92, + "duration_p99_ms": 49.84, + "duration_std_ms": 0.65, + "throughput_avg_mbps": 2379.73, + "throughput_min_mbps": 2247.38, + "throughput_max_mbps": 2416.15, + "ops_per_sec_avg": 10878.77, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 4.97, + "duration_min_ms": 4.55, + "duration_max_ms": 5.17, + "duration_p50_ms": 5.01, + "duration_p99_ms": 5.17, + "duration_std_ms": 0.15, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 103021.73, + "latency_per_key_ms": 0.01 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.3, + "duration_min_ms": 9.04, + "duration_max_ms": 95.81, + "duration_p50_ms": 9.33, + "duration_p99_ms": 95.81, + "duration_std_ms": 15.78, + "throughput_avg_mbps": 11548.94, + "throughput_min_mbps": 1169.02, + "throughput_max_mbps": 12386.5, + "ops_per_sec_avg": 52795.14, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-1.json new file mode 100644 index 0000000..efcae27 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.86, + "duration_min_ms": 46.19, + "duration_max_ms": 50.1, + "duration_p50_ms": 46.76, + "duration_p99_ms": 50.1, + "duration_std_ms": 0.76, + "throughput_avg_mbps": 2390.6, + "throughput_min_mbps": 2235.69, + "throughput_max_mbps": 2424.68, + "ops_per_sec_avg": 10928.46, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 8.38, + "duration_min_ms": 5.18, + "duration_max_ms": 87.55, + "duration_p50_ms": 5.52, + "duration_p99_ms": 87.55, + "duration_std_ms": 14.96, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 88183.17, + "latency_per_key_ms": 0.016, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.14, + "duration_min_ms": 8.88, + "duration_max_ms": 9.58, + "duration_p50_ms": 9.09, + "duration_p99_ms": 9.58, + "duration_std_ms": 0.19, + "throughput_avg_mbps": 12257.31, + "throughput_min_mbps": 11689.86, + "throughput_max_mbps": 12618.8, + "ops_per_sec_avg": 56033.44, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-2.json new file mode 100644 index 0000000..4d6fb89 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.87, + "duration_min_ms": 46.28, + "duration_max_ms": 49.81, + "duration_p50_ms": 46.76, + "duration_p99_ms": 49.81, + "duration_std_ms": 0.67, + "throughput_avg_mbps": 2390.2, + "throughput_min_mbps": 2248.73, + "throughput_max_mbps": 2419.92, + "ops_per_sec_avg": 10926.62, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 8.87, + "duration_min_ms": 5.16, + "duration_max_ms": 87.6, + "duration_p50_ms": 6.12, + "duration_p99_ms": 87.6, + "duration_std_ms": 14.9, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 82195.9, + "latency_per_key_ms": 0.017, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.47, + "duration_min_ms": 9.14, + "duration_max_ms": 10.67, + "duration_p50_ms": 9.4, + "duration_p99_ms": 10.67, + "duration_std_ms": 0.28, + "throughput_avg_mbps": 11834.31, + "throughput_min_mbps": 10500.6, + "throughput_max_mbps": 12258.45, + "ops_per_sec_avg": 54099.7, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-3.json new file mode 100644 index 0000000..cae4cc7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w2_single-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.19, + "duration_min_ms": 46.27, + "duration_max_ms": 50.42, + "duration_p50_ms": 46.99, + "duration_p99_ms": 50.42, + "duration_std_ms": 0.74, + "throughput_avg_mbps": 2374.01, + "throughput_min_mbps": 2221.22, + "throughput_max_mbps": 2420.49, + "ops_per_sec_avg": 10852.6, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.08, + "duration_min_ms": 5.22, + "duration_max_ms": 90.17, + "duration_p50_ms": 6.37, + "duration_p99_ms": 90.17, + "duration_std_ms": 15.33, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 79730.0, + "latency_per_key_ms": 0.018, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.39, + "duration_min_ms": 9.0, + "duration_max_ms": 10.05, + "duration_p50_ms": 9.33, + "duration_p99_ms": 10.05, + "duration_std_ms": 0.25, + "throughput_avg_mbps": 11938.43, + "throughput_min_mbps": 11139.9, + "throughput_max_mbps": 12443.65, + "ops_per_sec_avg": 54575.68, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-1.json new file mode 100644 index 0000000..c9f7c9d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.68, + "duration_min_ms": 11.31, + "duration_max_ms": 12.25, + "duration_p50_ms": 11.68, + "duration_p99_ms": 12.25, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2398.27, + "throughput_min_mbps": 2285.97, + "throughput_max_mbps": 2475.01, + "ops_per_sec_avg": 10963.52, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.34, + "duration_min_ms": 0.3, + "duration_max_ms": 0.38, + "duration_p50_ms": 0.33, + "duration_p99_ms": 0.38, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 380345.89, + "latency_per_key_ms": 0.003 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.83, + "duration_min_ms": 1.65, + "duration_max_ms": 2.02, + "duration_p50_ms": 1.82, + "duration_p99_ms": 2.02, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 15317.43, + "throughput_min_mbps": 13854.27, + "throughput_max_mbps": 16991.88, + "ops_per_sec_avg": 70022.52, + "latency_per_key_ms": 0.014 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-2.json new file mode 100644 index 0000000..b03b5e8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.88, + "duration_min_ms": 11.6, + "duration_max_ms": 12.32, + "duration_p50_ms": 11.88, + "duration_p99_ms": 12.32, + "duration_std_ms": 0.17, + "throughput_avg_mbps": 2357.11, + "throughput_min_mbps": 2273.56, + "throughput_max_mbps": 2414.63, + "ops_per_sec_avg": 10775.38, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.34, + "duration_min_ms": 0.3, + "duration_max_ms": 0.39, + "duration_p50_ms": 0.33, + "duration_p99_ms": 0.39, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 375481.31, + "latency_per_key_ms": 0.003 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.95, + "duration_min_ms": 1.73, + "duration_max_ms": 2.37, + "duration_p50_ms": 1.93, + "duration_p99_ms": 2.37, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 14415.8, + "throughput_min_mbps": 11833.54, + "throughput_max_mbps": 16196.51, + "ops_per_sec_avg": 65900.8, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-3.json new file mode 100644 index 0000000..6433289 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.91, + "duration_min_ms": 11.61, + "duration_max_ms": 12.44, + "duration_p50_ms": 11.88, + "duration_p99_ms": 12.44, + "duration_std_ms": 0.2, + "throughput_avg_mbps": 2352.35, + "throughput_min_mbps": 2251.22, + "throughput_max_mbps": 2411.7, + "ops_per_sec_avg": 10753.61, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.34, + "duration_min_ms": 0.31, + "duration_max_ms": 0.43, + "duration_p50_ms": 0.34, + "duration_p99_ms": 0.43, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 374439.75, + "latency_per_key_ms": 0.003 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.98, + "duration_min_ms": 1.73, + "duration_max_ms": 2.15, + "duration_p50_ms": 1.98, + "duration_p99_ms": 2.15, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14157.96, + "throughput_min_mbps": 13003.93, + "throughput_max_mbps": 16218.59, + "ops_per_sec_avg": 64722.1, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-1.json new file mode 100644 index 0000000..38dd468 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.72, + "duration_min_ms": 11.35, + "duration_max_ms": 12.52, + "duration_p50_ms": 11.68, + "duration_p99_ms": 12.52, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2389.96, + "throughput_min_mbps": 2237.16, + "throughput_max_mbps": 2466.36, + "ops_per_sec_avg": 10925.53, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.49, + "duration_min_ms": 0.44, + "duration_max_ms": 0.56, + "duration_p50_ms": 0.48, + "duration_p99_ms": 0.56, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 263778.95, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.98, + "duration_min_ms": 1.83, + "duration_max_ms": 2.24, + "duration_p50_ms": 1.95, + "duration_p99_ms": 2.24, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14208.04, + "throughput_min_mbps": 12485.88, + "throughput_max_mbps": 15322.29, + "ops_per_sec_avg": 64951.03, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-2.json new file mode 100644 index 0000000..f93b8b7 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.89, + "duration_min_ms": 11.52, + "duration_max_ms": 12.44, + "duration_p50_ms": 11.83, + "duration_p99_ms": 12.44, + "duration_std_ms": 0.24, + "throughput_avg_mbps": 2356.41, + "throughput_min_mbps": 2250.67, + "throughput_max_mbps": 2431.06, + "ops_per_sec_avg": 10772.17, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.46, + "duration_min_ms": 0.43, + "duration_max_ms": 0.52, + "duration_p50_ms": 0.45, + "duration_p99_ms": 0.52, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 278915.8, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.97, + "duration_min_ms": 1.72, + "duration_max_ms": 2.37, + "duration_p50_ms": 1.96, + "duration_p99_ms": 2.37, + "duration_std_ms": 0.13, + "throughput_avg_mbps": 14280.44, + "throughput_min_mbps": 11811.04, + "throughput_max_mbps": 16253.21, + "ops_per_sec_avg": 65282.0, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-3.json new file mode 100644 index 0000000..7093c69 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.88, + "duration_min_ms": 11.56, + "duration_max_ms": 12.3, + "duration_p50_ms": 11.86, + "duration_p99_ms": 12.3, + "duration_std_ms": 0.19, + "throughput_avg_mbps": 2356.73, + "throughput_min_mbps": 2276.59, + "throughput_max_mbps": 2421.53, + "ops_per_sec_avg": 10773.63, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.5, + "duration_min_ms": 0.45, + "duration_max_ms": 0.58, + "duration_p50_ms": 0.5, + "duration_p99_ms": 0.58, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 254741.75, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.91, + "duration_min_ms": 1.77, + "duration_max_ms": 2.2, + "duration_p50_ms": 1.9, + "duration_p99_ms": 2.2, + "duration_std_ms": 0.09, + "throughput_avg_mbps": 14672.22, + "throughput_min_mbps": 12739.9, + "throughput_max_mbps": 15801.71, + "ops_per_sec_avg": 67072.98, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-1.json new file mode 100644 index 0000000..59a4ede --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.81, + "duration_min_ms": 46.1, + "duration_max_ms": 50.41, + "duration_p50_ms": 46.67, + "duration_p99_ms": 50.41, + "duration_std_ms": 0.78, + "throughput_avg_mbps": 2393.16, + "throughput_min_mbps": 2221.82, + "throughput_max_mbps": 2429.33, + "ops_per_sec_avg": 10940.14, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 1.2, + "duration_min_ms": 1.08, + "duration_max_ms": 1.33, + "duration_p50_ms": 1.2, + "duration_p99_ms": 1.33, + "duration_std_ms": 0.05, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 429228.92, + "latency_per_key_ms": 0.002 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.45, + "duration_min_ms": 9.12, + "duration_max_ms": 95.54, + "duration_p50_ms": 9.42, + "duration_p99_ms": 95.54, + "duration_std_ms": 15.7, + "throughput_avg_mbps": 11369.88, + "throughput_min_mbps": 1172.25, + "throughput_max_mbps": 12284.57, + "ops_per_sec_avg": 51976.61, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-2.json new file mode 100644 index 0000000..abada4d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.63, + "duration_min_ms": 45.87, + "duration_max_ms": 49.1, + "duration_p50_ms": 46.42, + "duration_p99_ms": 49.1, + "duration_std_ms": 0.69, + "throughput_avg_mbps": 2402.24, + "throughput_min_mbps": 2280.88, + "throughput_max_mbps": 2441.77, + "ops_per_sec_avg": 10981.69, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 1.25, + "duration_min_ms": 1.11, + "duration_max_ms": 1.47, + "duration_p50_ms": 1.25, + "duration_p99_ms": 1.47, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 410870.62, + "latency_per_key_ms": 0.002 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.4, + "duration_min_ms": 9.09, + "duration_max_ms": 93.97, + "duration_p50_ms": 9.31, + "duration_p99_ms": 93.97, + "duration_std_ms": 15.42, + "throughput_avg_mbps": 11390.53, + "throughput_min_mbps": 1191.9, + "throughput_max_mbps": 12314.78, + "ops_per_sec_avg": 52071.0, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-3.json new file mode 100644 index 0000000..f480c47 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.95, + "duration_min_ms": 46.27, + "duration_max_ms": 49.53, + "duration_p50_ms": 46.78, + "duration_p99_ms": 49.53, + "duration_std_ms": 0.66, + "throughput_avg_mbps": 2385.82, + "throughput_min_mbps": 2261.29, + "throughput_max_mbps": 2420.55, + "ops_per_sec_avg": 10906.62, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 1.22, + "duration_min_ms": 1.15, + "duration_max_ms": 1.33, + "duration_p50_ms": 1.21, + "duration_p99_ms": 1.33, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 421446.42, + "latency_per_key_ms": 0.002 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.29, + "duration_min_ms": 9.06, + "duration_max_ms": 95.62, + "duration_p50_ms": 9.31, + "duration_p99_ms": 95.62, + "duration_std_ms": 15.74, + "throughput_avg_mbps": 11549.78, + "throughput_min_mbps": 1171.26, + "throughput_max_mbps": 12355.26, + "ops_per_sec_avg": 52799.02, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-1.json new file mode 100644 index 0000000..d4b75f3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.88, + "duration_min_ms": 46.29, + "duration_max_ms": 49.93, + "duration_p50_ms": 46.69, + "duration_p99_ms": 49.93, + "duration_std_ms": 0.73, + "throughput_avg_mbps": 2389.59, + "throughput_min_mbps": 2243.14, + "throughput_max_mbps": 2419.44, + "ops_per_sec_avg": 10923.83, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 4.7, + "duration_min_ms": 1.51, + "duration_max_ms": 87.82, + "duration_p50_ms": 1.89, + "duration_p99_ms": 87.82, + "duration_std_ms": 15.7, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 272315.69, + "latency_per_key_ms": 0.009, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.48, + "duration_min_ms": 9.2, + "duration_max_ms": 11.96, + "duration_p50_ms": 9.33, + "duration_p99_ms": 11.96, + "duration_std_ms": 0.5, + "throughput_avg_mbps": 11835.48, + "throughput_min_mbps": 9363.18, + "throughput_max_mbps": 12177.35, + "ops_per_sec_avg": 54105.03, + "latency_per_key_ms": 0.019 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-2.json new file mode 100644 index 0000000..fac5250 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.79, + "duration_min_ms": 46.04, + "duration_max_ms": 49.74, + "duration_p50_ms": 46.7, + "duration_p99_ms": 49.74, + "duration_std_ms": 0.71, + "throughput_avg_mbps": 2394.11, + "throughput_min_mbps": 2251.72, + "throughput_max_mbps": 2432.61, + "ops_per_sec_avg": 10944.49, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 1.83, + "duration_min_ms": 1.53, + "duration_max_ms": 2.21, + "duration_p50_ms": 1.86, + "duration_p99_ms": 2.21, + "duration_std_ms": 0.16, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 281854.65, + "latency_per_key_ms": 0.004, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.66, + "duration_min_ms": 9.22, + "duration_max_ms": 11.27, + "duration_p50_ms": 9.51, + "duration_p99_ms": 11.27, + "duration_std_ms": 0.44, + "throughput_avg_mbps": 11620.87, + "throughput_min_mbps": 9936.05, + "throughput_max_mbps": 12148.33, + "ops_per_sec_avg": 53124.0, + "latency_per_key_ms": 0.019 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-3.json new file mode 100644 index 0000000..4fc2ff8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_batch-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.0, + "duration_min_ms": 46.32, + "duration_max_ms": 49.35, + "duration_p50_ms": 46.82, + "duration_p99_ms": 49.35, + "duration_std_ms": 0.61, + "throughput_avg_mbps": 2383.44, + "throughput_min_mbps": 2269.28, + "throughput_max_mbps": 2417.9, + "ops_per_sec_avg": 10895.74, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 4.77, + "duration_min_ms": 1.68, + "duration_max_ms": 87.57, + "duration_p50_ms": 1.93, + "duration_p99_ms": 87.57, + "duration_std_ms": 15.64, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 259846.87, + "latency_per_key_ms": 0.009, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.35, + "duration_min_ms": 9.06, + "duration_max_ms": 9.98, + "duration_p50_ms": 9.28, + "duration_p99_ms": 9.98, + "duration_std_ms": 0.25, + "throughput_avg_mbps": 11981.68, + "throughput_min_mbps": 11226.68, + "throughput_max_mbps": 12364.27, + "ops_per_sec_avg": 54773.38, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-1.json new file mode 100644 index 0000000..b2b55e3 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.71, + "duration_min_ms": 11.28, + "duration_max_ms": 12.15, + "duration_p50_ms": 11.71, + "duration_p99_ms": 12.15, + "duration_std_ms": 0.2, + "throughput_avg_mbps": 2391.13, + "throughput_min_mbps": 2305.28, + "throughput_max_mbps": 2482.66, + "ops_per_sec_avg": 10930.87, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.82, + "duration_min_ms": 0.78, + "duration_max_ms": 0.89, + "duration_p50_ms": 0.82, + "duration_p99_ms": 0.89, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 156436.16, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.86, + "duration_min_ms": 1.6, + "duration_max_ms": 2.11, + "duration_p50_ms": 1.86, + "duration_p99_ms": 2.11, + "duration_std_ms": 0.11, + "throughput_avg_mbps": 15071.21, + "throughput_min_mbps": 13263.75, + "throughput_max_mbps": 17523.2, + "ops_per_sec_avg": 68896.96, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-2.json new file mode 100644 index 0000000..21974a2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.8, + "duration_min_ms": 11.5, + "duration_max_ms": 12.53, + "duration_p50_ms": 11.74, + "duration_p99_ms": 12.53, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2373.47, + "throughput_min_mbps": 2235.48, + "throughput_max_mbps": 2435.8, + "ops_per_sec_avg": 10850.13, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.83, + "duration_min_ms": 0.77, + "duration_max_ms": 0.88, + "duration_p50_ms": 0.83, + "duration_p99_ms": 0.88, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 153980.5, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.92, + "duration_min_ms": 1.73, + "duration_max_ms": 2.36, + "duration_p50_ms": 1.91, + "duration_p99_ms": 2.36, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 14594.89, + "throughput_min_mbps": 11882.59, + "throughput_max_mbps": 16155.96, + "ops_per_sec_avg": 66719.5, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-3.json new file mode 100644 index 0000000..9c1d15a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.87, + "duration_min_ms": 11.49, + "duration_max_ms": 12.45, + "duration_p50_ms": 11.82, + "duration_p99_ms": 12.45, + "duration_std_ms": 0.23, + "throughput_avg_mbps": 2360.16, + "throughput_min_mbps": 2249.55, + "throughput_max_mbps": 2437.03, + "ops_per_sec_avg": 10789.29, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 0, + "duration_avg_ms": 0.83, + "duration_min_ms": 0.79, + "duration_max_ms": 0.87, + "duration_p50_ms": 0.83, + "duration_p99_ms": 0.87, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 154563.97, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.0, + "duration_min_ms": 1.87, + "duration_max_ms": 2.16, + "duration_p50_ms": 1.99, + "duration_p99_ms": 2.16, + "duration_std_ms": 0.06, + "throughput_avg_mbps": 14022.46, + "throughput_min_mbps": 12991.11, + "throughput_max_mbps": 14942.49, + "ops_per_sec_avg": 64102.67, + "latency_per_key_ms": 0.016 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-1.json new file mode 100644 index 0000000..60056ca --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.63, + "duration_min_ms": 11.25, + "duration_max_ms": 12.26, + "duration_p50_ms": 11.59, + "duration_p99_ms": 12.26, + "duration_std_ms": 0.23, + "throughput_avg_mbps": 2409.39, + "throughput_min_mbps": 2283.6, + "throughput_max_mbps": 2487.79, + "ops_per_sec_avg": 11014.35, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.0, + "duration_min_ms": 0.94, + "duration_max_ms": 1.08, + "duration_p50_ms": 0.99, + "duration_p99_ms": 1.08, + "duration_std_ms": 0.03, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 128655.33, + "latency_per_key_ms": 0.008, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.93, + "duration_min_ms": 1.72, + "duration_max_ms": 2.12, + "duration_p50_ms": 1.93, + "duration_p99_ms": 2.12, + "duration_std_ms": 0.1, + "throughput_avg_mbps": 14517.53, + "throughput_min_mbps": 13220.96, + "throughput_max_mbps": 16326.31, + "ops_per_sec_avg": 66365.84, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-2.json new file mode 100644 index 0000000..9eae7fe --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.76, + "duration_min_ms": 11.45, + "duration_max_ms": 12.41, + "duration_p50_ms": 11.72, + "duration_p99_ms": 12.41, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 2382.66, + "throughput_min_mbps": 2255.66, + "throughput_max_mbps": 2446.2, + "ops_per_sec_avg": 10892.15, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.99, + "duration_min_ms": 0.95, + "duration_max_ms": 1.04, + "duration_p50_ms": 0.99, + "duration_p99_ms": 1.04, + "duration_std_ms": 0.02, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 128884.03, + "latency_per_key_ms": 0.008, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 2.01, + "duration_min_ms": 1.87, + "duration_max_ms": 2.25, + "duration_p50_ms": 2.0, + "duration_p99_ms": 2.25, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 13976.31, + "throughput_min_mbps": 12450.61, + "throughput_max_mbps": 14992.11, + "ops_per_sec_avg": 63891.68, + "latency_per_key_ms": 0.016 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-3.json new file mode 100644 index 0000000..5c9b20d --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if16-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 16, + "keys_per_round": 128, + "data_size_kb": 224, + "data_per_round_mb": 28.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 11.84, + "duration_min_ms": 11.53, + "duration_max_ms": 12.32, + "duration_p50_ms": 11.78, + "duration_p99_ms": 12.32, + "duration_std_ms": 0.21, + "throughput_avg_mbps": 2365.55, + "throughput_min_mbps": 2272.24, + "throughput_max_mbps": 2428.41, + "ops_per_sec_avg": 10813.95, + "latency_per_key_ms": 0.093 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 0.95, + "duration_min_ms": 0.9, + "duration_max_ms": 1.02, + "duration_p50_ms": 0.94, + "duration_p99_ms": 1.02, + "duration_std_ms": 0.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 134483.74, + "latency_per_key_ms": 0.007, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 3291, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 128, + "total_keys": 3840, + "total_success": 3840, + "duration_avg_ms": 1.93, + "duration_min_ms": 1.76, + "duration_max_ms": 2.13, + "duration_p50_ms": 1.92, + "duration_p99_ms": 2.13, + "duration_std_ms": 0.08, + "throughput_avg_mbps": 14535.33, + "throughput_min_mbps": 13116.59, + "throughput_max_mbps": 15894.46, + "ops_per_sec_avg": 66447.24, + "latency_per_key_ms": 0.015 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-1.json new file mode 100644 index 0000000..b52b7d8 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-1.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.52, + "duration_min_ms": 45.94, + "duration_max_ms": 49.51, + "duration_p50_ms": 46.3, + "duration_p99_ms": 49.51, + "duration_std_ms": 0.69, + "throughput_avg_mbps": 2408.06, + "throughput_min_mbps": 2262.27, + "throughput_max_mbps": 2437.94, + "ops_per_sec_avg": 11008.3, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 3.42, + "duration_min_ms": 3.13, + "duration_max_ms": 3.79, + "duration_p50_ms": 3.37, + "duration_p99_ms": 3.79, + "duration_std_ms": 0.22, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 150443.79, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.25, + "duration_min_ms": 8.99, + "duration_max_ms": 94.64, + "duration_p50_ms": 9.26, + "duration_p99_ms": 94.64, + "duration_std_ms": 15.57, + "throughput_avg_mbps": 11569.22, + "throughput_min_mbps": 1183.49, + "throughput_max_mbps": 12458.42, + "ops_per_sec_avg": 52887.85, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-2.json new file mode 100644 index 0000000..7ca44ee --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-2.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.76, + "duration_min_ms": 45.91, + "duration_max_ms": 49.55, + "duration_p50_ms": 46.62, + "duration_p99_ms": 49.55, + "duration_std_ms": 0.69, + "throughput_avg_mbps": 2395.44, + "throughput_min_mbps": 2260.29, + "throughput_max_mbps": 2439.29, + "ops_per_sec_avg": 10950.58, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 3.68, + "duration_min_ms": 3.13, + "duration_max_ms": 5.31, + "duration_p50_ms": 3.24, + "duration_p99_ms": 5.31, + "duration_std_ms": 0.79, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 144269.96, + "latency_per_key_ms": 0.007 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.22, + "duration_min_ms": 9.0, + "duration_max_ms": 95.24, + "duration_p50_ms": 9.28, + "duration_p99_ms": 95.24, + "duration_std_ms": 15.68, + "throughput_avg_mbps": 11613.12, + "throughput_min_mbps": 1175.92, + "throughput_max_mbps": 12438.6, + "ops_per_sec_avg": 53088.56, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-3.json new file mode 100644 index 0000000..9dbad9a --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit0-3.json @@ -0,0 +1,73 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 0.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.97, + "duration_min_ms": 46.36, + "duration_max_ms": 50.09, + "duration_p50_ms": 46.74, + "duration_p99_ms": 50.09, + "duration_std_ms": 0.7, + "throughput_avg_mbps": 2384.89, + "throughput_min_mbps": 2236.11, + "throughput_max_mbps": 2415.97, + "ops_per_sec_avg": 10902.37, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 0, + "duration_avg_ms": 3.12, + "duration_min_ms": 2.9, + "duration_max_ms": 3.4, + "duration_p50_ms": 3.11, + "duration_p99_ms": 3.4, + "duration_std_ms": 0.12, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 164089.89, + "latency_per_key_ms": 0.006 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 12.25, + "duration_min_ms": 9.02, + "duration_max_ms": 94.98, + "duration_p50_ms": 9.41, + "duration_p99_ms": 94.98, + "duration_std_ms": 15.63, + "throughput_avg_mbps": 11566.68, + "throughput_min_mbps": 1179.18, + "throughput_max_mbps": 12422.11, + "ops_per_sec_avg": 52876.25, + "latency_per_key_ms": 0.024 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-1.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-1.json new file mode 100644 index 0000000..29cbbdf --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-1.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.64, + "duration_min_ms": 46.18, + "duration_max_ms": 49.32, + "duration_p50_ms": 46.46, + "duration_p99_ms": 49.32, + "duration_std_ms": 0.6, + "throughput_avg_mbps": 2401.81, + "throughput_min_mbps": 2270.66, + "throughput_max_mbps": 2425.43, + "ops_per_sec_avg": 10979.72, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 7.81, + "duration_min_ms": 3.61, + "duration_max_ms": 82.78, + "duration_p50_ms": 4.73, + "duration_p99_ms": 82.78, + "duration_std_ms": 14.25, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 102759.97, + "latency_per_key_ms": 0.015, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.24, + "duration_min_ms": 8.96, + "duration_max_ms": 9.82, + "duration_p50_ms": 9.2, + "duration_p99_ms": 9.82, + "duration_std_ms": 0.2, + "throughput_avg_mbps": 12121.82, + "throughput_min_mbps": 11411.09, + "throughput_max_mbps": 12496.39, + "ops_per_sec_avg": 55414.03, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-2.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-2.json new file mode 100644 index 0000000..0a4dc64 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-2.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 46.67, + "duration_min_ms": 45.9, + "duration_max_ms": 49.64, + "duration_p50_ms": 46.48, + "duration_p99_ms": 49.64, + "duration_std_ms": 0.66, + "throughput_avg_mbps": 2400.5, + "throughput_min_mbps": 2256.11, + "throughput_max_mbps": 2439.94, + "ops_per_sec_avg": 10973.72, + "latency_per_key_ms": 0.091 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 7.02, + "duration_min_ms": 3.6, + "duration_max_ms": 86.62, + "duration_p50_ms": 4.43, + "duration_p99_ms": 86.62, + "duration_std_ms": 15.04, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 116963.02, + "latency_per_key_ms": 0.014, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.38, + "duration_min_ms": 8.95, + "duration_max_ms": 9.98, + "duration_p50_ms": 9.29, + "duration_p99_ms": 9.98, + "duration_std_ms": 0.28, + "throughput_avg_mbps": 11944.83, + "throughput_min_mbps": 11225.17, + "throughput_max_mbps": 12514.56, + "ops_per_sec_avg": 54604.94, + "latency_per_key_ms": 0.018 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-3.json b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-3.json new file mode 100644 index 0000000..59bb8a2 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/lmcache/rust_w4_single-if64-hit1.0-3.json @@ -0,0 +1,76 @@ +{ + "title": "L2 Adapter Benchmark Result", + "metrics": { + "config": { + "l2_adapter_json": "{\"type\":\"native_plugin\",\"module_path\":\"hypercache_lmcache_native\",\"class_name\":\"HyperCacheNativeConnector\",\"adapter_params\":{\"namespace\":\"bench\",\"socket_path\":\"/dev/shm/lp/run/s\",\"tier\":\"nvme\",\"num_workers\":8},\"max_capacity_gb\":0}", + "num_keys": 8, + "in_flight": 64, + "keys_per_round": 512, + "data_size_kb": 224, + "data_per_round_mb": 112.0, + "measurement_rounds": 30, + "warmup_rounds": 5, + "lookup_max_hit_rate": 1.0 + }, + "op_0": { + "operation": "Store", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 47.02, + "duration_min_ms": 46.41, + "duration_max_ms": 49.63, + "duration_p50_ms": 46.83, + "duration_p99_ms": 49.63, + "duration_std_ms": 0.65, + "throughput_avg_mbps": 2382.41, + "throughput_min_mbps": 2256.82, + "throughput_max_mbps": 2413.5, + "ops_per_sec_avg": 10891.02, + "latency_per_key_ms": 0.092 + }, + "op_1": { + "operation": "Lookup", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 7.52, + "duration_min_ms": 3.67, + "duration_max_ms": 85.56, + "duration_p50_ms": 4.52, + "duration_p99_ms": 85.56, + "duration_std_ms": 14.79, + "throughput_avg_mbps": 0.0, + "throughput_min_mbps": 0.0, + "throughput_max_mbps": 0.0, + "ops_per_sec_avg": 108113.59, + "latency_per_key_ms": 0.015, + "expected_max_hit_rate": 1.0, + "expected_hit_count": 13165, + "actual_hit_rate": 1.0 + }, + "op_2": { + "operation": "Load", + "rounds": 30, + "rounds_timed_out": 0, + "keys_per_round": 512, + "total_keys": 15360, + "total_success": 15360, + "duration_avg_ms": 9.51, + "duration_min_ms": 9.03, + "duration_max_ms": 10.67, + "duration_p50_ms": 9.36, + "duration_p99_ms": 10.67, + "duration_std_ms": 0.38, + "throughput_avg_mbps": 11790.35, + "throughput_min_mbps": 10494.43, + "throughput_max_mbps": 12406.57, + "ops_per_sec_avg": 53898.76, + "latency_per_key_ms": 0.019 + } + } +} diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_fixed_rate_lookups.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_fixed_rate_lookups.txt new file mode 100644 index 0000000..ac4a354 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_fixed_rate_lookups.txt @@ -0,0 +1,14 @@ +== w2_single +rate 5000 rep0: alone 17741 MB/s, with lookups 17217 MB/s (-3.0% change), achieved 4999 keys/s +rate 5000 rep1: alone 17769 MB/s, with lookups 17218 MB/s (-3.1% change), achieved 5001 keys/s +rate 5000 rep2: alone 17779 MB/s, with lookups 17218 MB/s (-3.2% change), achieved 5000 keys/s +rate 20000 rep0: alone 17764 MB/s, with lookups 16636 MB/s (-6.4% change), achieved 19229 keys/s +rate 20000 rep1: alone 17800 MB/s, with lookups 16657 MB/s (-6.4% change), achieved 19281 keys/s +rate 20000 rep2: alone 17763 MB/s, with lookups 16485 MB/s (-7.2% change), achieved 19133 keys/s +== w4_batch +rate 5000 rep0: alone 18121 MB/s, with lookups 17649 MB/s (-2.6% change), achieved 5000 keys/s +rate 5000 rep1: alone 18191 MB/s, with lookups 17659 MB/s (-2.9% change), achieved 5000 keys/s +rate 5000 rep2: alone 18121 MB/s, with lookups 17637 MB/s (-2.7% change), achieved 5000 keys/s +rate 20000 rep0: alone 18150 MB/s, with lookups 16580 MB/s (-8.7% change), achieved 19998 keys/s +rate 20000 rep1: alone 18279 MB/s, with lookups 16571 MB/s (-9.3% change), achieved 19999 keys/s +rate 20000 rep2: alone 18222 MB/s, with lookups 16725 MB/s (-8.2% change), achieved 19999 keys/s diff --git a/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_unlimited_lookups.txt b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_unlimited_lookups.txt new file mode 100644 index 0000000..1438e73 --- /dev/null +++ b/benchmarks/results/lmcache_l2_raw/rust-connector-lookup/loads_with_unlimited_lookups.txt @@ -0,0 +1,16 @@ +== w2_single +load_vs_lookup rep0: alone 18078 MB/s, with lookups 15897 MB/s (-12.1% change), lookups 36235 keys/s +load_vs_lookup rep1: alone 18128 MB/s, with lookups 15906 MB/s (-12.3% change), lookups 36073 keys/s +load_vs_lookup rep2: alone 18136 MB/s, with lookups 15901 MB/s (-12.3% change), lookups 36045 keys/s +== w4_single +load_vs_lookup rep0: alone 17646 MB/s, with lookups 14908 MB/s (-15.5% change), lookups 57954 keys/s +load_vs_lookup rep1: alone 17685 MB/s, with lookups 15059 MB/s (-14.9% change), lookups 58164 keys/s +load_vs_lookup rep2: alone 18107 MB/s, with lookups 14960 MB/s (-17.4% change), lookups 58022 keys/s +== w2_batch +load_vs_lookup rep0: alone 18195 MB/s, with lookups 13847 MB/s (-23.9% change), lookups 113232 keys/s +load_vs_lookup rep1: alone 18197 MB/s, with lookups 13683 MB/s (-24.8% change), lookups 111435 keys/s +load_vs_lookup rep2: alone 18206 MB/s, with lookups 14112 MB/s (-22.5% change), lookups 115467 keys/s +== w4_batch +load_vs_lookup rep0: alone 18429 MB/s, with lookups 12326 MB/s (-33.1% change), lookups 176048 keys/s +load_vs_lookup rep1: alone 18490 MB/s, with lookups 12209 MB/s (-34.0% change), lookups 174833 keys/s +load_vs_lookup rep2: alone 18506 MB/s, with lookups 12123 MB/s (-34.5% change), lookups 174900 keys/s diff --git a/benchmarks/results/lmcache_rust_connector_nvme.md b/benchmarks/results/lmcache_rust_connector_nvme.md index 5afbc27..3f920c8 100644 --- a/benchmarks/results/lmcache_rust_connector_nvme.md +++ b/benchmarks/results/lmcache_rust_connector_nvme.md @@ -14,7 +14,7 @@ Measured 2026-11-04 on a rented bare-metal node with no GPU. Raw data is in `lmc - **The stripe fix matters most for small objects.** 2 MiB objects load 3.9 times as fast, because they used to land on one drive. - **On 4 drives, the connector matches the best `raw_block` result on RAID 0, and holds it.** `raw_block` on RAID 0 reached the same speed in 2 of 6 runs and got stuck near 15.2 GB/s in the other 4. The cause isn't known, and could be our array setup. - **No load returned wrong bytes** across crashes, restarts, corruption, eviction and a 30-minute soak. -- **Lookups are slower than `raw_block`'s**, at about 2.6 ms against 0.9-1.0 ms on one drive. +- **Lookups were slower than `raw_block`'s on this node**, at about 2.6 ms against 0.9-1.0 ms per round on one drive. A later change made them faster than `raw_block`'s on a Ryzen 5 5600, which hasn't been repeated on this node. See [lookup speed](#lookup-speed). - **Full-speed writes cut reads hard.** Most of that comes from the drives themselves. See [mixed reads and writes](#mixed-reads-and-writes). ## What the drives can do without HyperCache @@ -94,6 +94,38 @@ These one-drive runs used the old daemon. With one drive, every object starts on Don't read the stuck 15.2 GB/s runs as a general fault of RAID 0 or `raw_block`. It could come from either of those or from our array settings, and we didn't look for the cause. The comparison shows what we measured, without tuning `raw_block`'s setup. +## Lookup speed + +The "Lookup ms" columns above came before this change. They time a whole round (`in_flight * 8` keys), and every lookup in them was a miss, because `--lookup-max-hit-rate` defaults to 0. Per key, that's about 20 µs for Rust against 7.6 µs for `raw_block` on this node, at any queue depth, drive count or worker count. + +**Cause:** the connector made one socket round trip per key, on 2 lookup workers. On the 5600, that accounted for about 80% of its lookup time. The connector now sends each batch's lookups in one write and uses 4 lookup workers. The daemon and its protocol didn't change. + +**Measured 2026-11-05 on a different machine:** Ryzen 5 5600 (6 cores), 31 GB RAM, Linux 6.8.0, LMCache 0.5.6, no drive involved because a lookup does no drive I/O. Objects were 224 KiB at 64 KiB per chunk, so each still has 4 chunks and a normal-length reply. Raw data is in `lmcache_l2_raw/rust-connector-lookup/`. + +µs per key, 8 keys per batch, median of 3 with the range in brackets, 30 rounds plus 5 warm-up: + +| Setup | 16 in flight, hits | 16 in flight, misses | 64 in flight, hits | 64 in flight, misses | +|---|---|---|---|---| +| Rust, 2 workers, one round trip per key (before) | 11.56 [10.00-11.88] | 9.84 [7.97-10.55] | 11.95 [10.78-12.44] | 9.77 [9.22-9.79] | +| Rust, 4 workers, one round trip per key | 7.73 [7.34-7.73] | 6.48 [6.41-6.48] | 8.83 [8.65-9.24] | 6.33 [6.07-6.58] | +| Rust, 2 workers, batched | 6.64 [5.31-6.88] | 4.69 [3.91-4.84] | 6.09 [5.86-6.46] | 4.82 [4.22-5.35] | +| **Rust, 4 workers, batched (now)** | **3.75 [3.52-3.91]** | **2.58 [2.58-2.66]** | **3.69 [3.63-3.77]** | **2.36 [2.34-2.44]** | +| `raw_block`, posix | 4.38 [4.30-4.38] | 4.06 [4.06-4.06] | 4.34 [4.26-4.59] | 3.91 [3.89-3.91] | +| `fs_native`, page cache on | 4.69 [4.61-4.84] | 3.83 [3.52-3.91] | 4.75 [4.43-5.00] | 3.85 [3.83-3.96] | + +**Effect on loads:** one lookup batch at a time at a fixed rate, with loads limited by CPU on tmpfs, which is a worst case. Bursts of lookups weren't tested. + +| Lookups | Loads before, MB/s (change from loads alone) | Loads now, MB/s (change from loads alone) | +|---|---|---| +| 5,000 keys/s | 17218 (-3.1%) | 17649 (-2.7%) | +| 20,000 keys/s | 16636 (-6.4%), reached about 19,200 keys/s | 16580 (-8.7%) | + +The two versions are about the same. The speed of loads alone moved by about 2% between sessions, which is similar in size to the differences here. + +**Safety on the final code:** run on the 5600, on loop devices on a RAM disk rather than real drives, with lower volumes to fit in RAM (256 objects, 4 GiB limits). The safety script passed 30 of 30 on LMCache 0.5.5 and 0.5.6, on 1 and 2 devices. All 19 failure tests passed. The 5 new ones cover lookups: each of 2,000 mixed batches returned the right result for every key, `kill -9` with and without saved metadata, a frozen daemon whose late replies must not answer later lookups, and deletes during lookups. No key that was never stored was ever reported as found. The upgrade test wasn't repeated, because the daemon didn't change. + +**Not known yet:** the speed on this EPYC node, where times were about twice as long before the change. + ## Mixed reads and writes No LMCache in the path. 4 drives, 14 MiB, one connector per direction with 32 workers and 64 in flight, 30 s each, 3 rounds, new keys for writes. Reads are in random order. From 30e40862782188442d93a83093519b6280ff6793 Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 20:54:46 -0600 Subject: [PATCH 8/9] docs(benchmarks): update the commit that holds the Python adapter The history rewrite that removed attribution lines changed this hash from 5108dcc to 5be16e3. --- benchmarks/results/lmcache_and_ttft.md | 2 +- benchmarks/results/lmcache_rust_connector.md | 2 +- benchmarks/results/lmcache_rust_connector_xeon.md | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/benchmarks/results/lmcache_and_ttft.md b/benchmarks/results/lmcache_and_ttft.md index 4f3d4d4..bb80a53 100644 --- a/benchmarks/results/lmcache_and_ttft.md +++ b/benchmarks/results/lmcache_and_ttft.md @@ -1,6 +1,6 @@ # LMCache adapter and pipelined loader results -Note: the Python adapter measured here was later replaced by the Rust connector in `lmcache-connector/`. It remains in git history at commit 5108dcc. +Note: the Python adapter measured here was later replaced by the Rust connector in `lmcache-connector/`. It remains in git history at commit 5be16e3. Measured 2026-11-02 on one small server. These results show behaviour and relative cost on this machine. They are not throughput claims for production hardware. diff --git a/benchmarks/results/lmcache_rust_connector.md b/benchmarks/results/lmcache_rust_connector.md index 5534a07..f713083 100644 --- a/benchmarks/results/lmcache_rust_connector.md +++ b/benchmarks/results/lmcache_rust_connector.md @@ -1,6 +1,6 @@ # Rust LMCache connector results -Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5108dcc. +Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5be16e3. Measured 2026-11-02 on one small server. These results show behaviour and relative cost on this machine. They are not throughput claims for production hardware. diff --git a/benchmarks/results/lmcache_rust_connector_xeon.md b/benchmarks/results/lmcache_rust_connector_xeon.md index 811726f..4469da6 100644 --- a/benchmarks/results/lmcache_rust_connector_xeon.md +++ b/benchmarks/results/lmcache_rust_connector_xeon.md @@ -1,6 +1,6 @@ # Rust LMCache connector results: Xeon VM, 4 network disks -Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5108dcc. +Note: the Python adapter compared here was later replaced by this connector. It remains in git history at commit 5be16e3. Measured 2026-11-03 on a rented cloud VM. Raw data is in `lmcache_l2_raw/rust-connector-xeon/`. Earlier results from a small server are in `lmcache_rust_connector.md`. From b11499056d4fe94b85166b9323b845e850f337ff Mon Sep 17 00:00:00 2001 From: neo-th Date: Wed, 4 Nov 2026 21:04:19 -0600 Subject: [PATCH 9/9] ci: build, lint and test the LMCache connector ci.yml never touched lmcache-connector/, so a green check said nothing about it. The steps are in the existing job, so the check that main requires covers them. The safety script still isn't in CI, because it needs LMCache and a running daemon. --- .github/workflows/ci.yml | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a25f756..8e9c336 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,7 +30,9 @@ jobs: - name: Cache Cargo registry and target uses: Swatinem/rust-cache@v2 with: - workspaces: "control-plane -> target" + workspaces: | + control-plane -> target + lmcache-connector -> target - name: Set up Python uses: actions/setup-python@v5 @@ -43,6 +45,16 @@ jobs: python -m pip install "numpy>=1.22" "fsspec>=2023.1.0" pytest boto3 safetensors pyyaml build sudo apt-get install -y -qq lsof + # In this job, not its own, so the check that main requires covers the connector too. + # The tests need no Python or LMCache. The Python bindings are only linted here. + - name: LMCache connector + working-directory: lmcache-connector + run: | + cargo fmt --check + cargo clippy --locked --all-targets -- -D warnings + cargo clippy --locked --features extension-module -- -D warnings + cargo test --locked + # Runs every stage except `linux` (the runner already is a clean Linux host) and `k8s` # (needs minikube). The s3 stage starts a throwaway versitygw container, and the image # stage builds the release image and tests host access to the containerized daemon.