From 1c164663f8b58b7e0600a079878f8a7b15eddfa2 Mon Sep 17 00:00:00 2001 From: Milind Srivastava Date: Sun, 11 Oct 2026 15:31:53 -0400 Subject: [PATCH] feat(bench): precompute-engine throughput vs CPU microbenchmark Adds a remote-write load generator (bench_ingest_sender) and a sweep/plot harness that measure the standalone precompute_engine's throughput against CPU for KLL, DDSketch, CMS+Heap and HydraKLL pipelines at 1K-1M series, plus fan-in, window-shape and core-scaling experiments. precompute_engine gains --num-aggregates-to-retain: without an inference config the standalone binary retained every window, so memory grew without bound over a benchmark run. Includes results from a CloudLab run and a HANDOFF.md on how to reproduce. Co-Authored-By: Claude Opus 5.5 --- asap-query-engine/Cargo.toml | 4 + .../src/bin/bench_ingest_sender.rs | 318 ++++++++++++++++++ .../src/bin/precompute_engine.rs | 13 +- .../precompute_throughput/HANDOFF.md | 141 ++++++++ .../configs/cms_heap.yaml | 20 ++ .../configs/ddsketch.yaml | 18 + .../configs/hydra_kll.yaml | 21 ++ .../precompute_throughput/configs/kll.yaml | 18 + .../microbench/precompute_throughput/plot.py | 138 ++++++++ .../precompute_throughput/results/fanin.jsonl | 3 + .../precompute_throughput/results/fanin.out | 7 + .../precompute_throughput/results/fanin.png | Bin 0 -> 15166 bytes .../precompute_throughput/results/main.jsonl | 120 +++++++ .../precompute_throughput/results/main.out | 241 +++++++++++++ .../precompute_throughput/results/main.pdf | Bin 0 -> 22279 bytes .../precompute_throughput/results/main.png | Bin 0 -> 103881 bytes .../results/main_noraw.jsonl | 96 ++++++ .../results/scaling.jsonl | 10 + .../precompute_throughput/results/scaling.out | 21 ++ .../precompute_throughput/results/scaling.png | Bin 0 -> 23543 bytes .../results/window.jsonl | 4 + .../precompute_throughput/results/window.out | 9 + .../precompute_throughput/results/window.png | Bin 0 -> 18169 bytes .../microbench/precompute_throughput/sweep.py | 270 +++++++++++++++ 24 files changed, 1471 insertions(+), 1 deletion(-) create mode 100644 asap-query-engine/src/bin/bench_ingest_sender.rs create mode 100644 asap-tools/experiments/microbench/precompute_throughput/HANDOFF.md create mode 100644 asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml create mode 100644 asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml create mode 100644 asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml create mode 100644 asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml create mode 100644 asap-tools/experiments/microbench/precompute_throughput/plot.py create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/fanin.jsonl create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/fanin.out create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/fanin.png create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/main.jsonl create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/main.out create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/main.pdf create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/main.png create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/main_noraw.jsonl create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/scaling.jsonl create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/scaling.out create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/scaling.png create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/window.jsonl create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/window.out create mode 100644 asap-tools/experiments/microbench/precompute_throughput/results/window.png create mode 100644 asap-tools/experiments/microbench/precompute_throughput/sweep.py diff --git a/asap-query-engine/Cargo.toml b/asap-query-engine/Cargo.toml index ed413a18..82f306d9 100644 --- a/asap-query-engine/Cargo.toml +++ b/asap-query-engine/Cargo.toml @@ -81,6 +81,10 @@ path = "src/bin/test_e2e_precompute.rs" name = "bench_precompute_sketch" path = "src/bin/bench_precompute_sketch.rs" +[[bin]] +name = "bench_ingest_sender" +path = "src/bin/bench_ingest_sender.rs" + [[bin]] name = "e2e_quickstart_resource_test" path = "src/bin/e2e_quickstart_resource_test.rs" diff --git a/asap-query-engine/src/bin/bench_ingest_sender.rs b/asap-query-engine/src/bin/bench_ingest_sender.rs new file mode 100644 index 00000000..ae8250c2 --- /dev/null +++ b/asap-query-engine/src/bin/bench_ingest_sender.rs @@ -0,0 +1,318 @@ +//! Remote-write load generator for throughput benchmarks of the standalone +//! `precompute_engine` binary. Run it as a separate process on separate cores +//! so its own CPU never counts against the engine. +//! +//! Series `i` carries labels `l0..l4` = the base-10 digits of `i` (`l4` takes +//! the remainder), so grouping by a label prefix gives a known fan-in. Each +//! pass sends one sample per series and advances event time by `step_ms`, so +//! window closes per sample are fixed regardless of send rate. +//! +//! Prints one JSON line: acked samples/sec and engine CPU cores over the +//! measurement window (after warmup). + +use clap::Parser; +use prost::Message; +use query_engine_rust::drivers::ingest::prometheus_remote_write::{ + Label, Sample, TimeSeries, WriteRequest, +}; +use std::ops::Range; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::Arc; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; +use tokio::sync::mpsc; + +const METRIC_NAME: &str = "bench_metric"; +const NUM_LABELS: usize = 5; +const LABEL_RADIX: usize = 10; +/// Sample values are uniform in `[0, VALUE_RANGE)`. +const VALUE_RANGE: f64 = 10_000.0; +/// Bodies an encoder thread may build ahead of its sender. +const ENCODE_AHEAD: usize = 8; +/// Max passes a sender may lead the slowest one. Groups span senders and the +/// engine keeps one watermark per group, so `MAX_PASS_SKEW * step_ms` must +/// stay below the engine's `--allowed_lateness_ms`, or the lagging sender's +/// samples are dropped as late. +const MAX_PASS_SKEW: u64 = 2; +const SKEW_POLL_INTERVAL: Duration = Duration::from_micros(200); + +#[derive(Parser, Debug)] +#[command(name = "bench_ingest_sender")] +struct Args { + /// PID of the precompute_engine process to measure. + #[arg(long)] + engine_pid: u32, + + #[arg(long)] + port: u16, + + #[arg(long)] + num_series: usize, + + /// Target samples/sec across all senders; 0 sends open-loop (saturation). + #[arg(long)] + target_rate: f64, + + /// Concurrent senders (capped at --num-series). Each owns a disjoint slice + /// of the series and keeps one request in flight (preserves per-series + /// order). The engine handles a request mostly serially, so this must be + /// at least the engine's core count to saturate it, even if that makes + /// requests smaller at low cardinality. + #[arg(long)] + concurrency: usize, + + /// Max samples per remote-write request (Prometheus' default + /// `max_samples_per_send` is 2000). Smaller when a sender's slice is. + #[arg(long)] + samples_per_request: usize, + + /// Event-time advance per pass (the simulated scrape interval). + #[arg(long)] + step_ms: i64, + + #[arg(long)] + warmup_secs: u64, + + #[arg(long)] + measure_secs: u64, +} + +type Body = (u64, u64, Vec); // (pass, samples, snappy-compressed body) + +fn make_series(i: usize) -> TimeSeries { + let mut labels = vec![Label { + name: "__name__".into(), + value: METRIC_NAME.into(), + }]; + let mut rest = i; + for l in 0..NUM_LABELS { + let digit = if l + 1 == NUM_LABELS { + rest + } else { + rest % LABEL_RADIX + }; + rest /= LABEL_RADIX; + labels.push(Label { + name: format!("l{l}"), + value: format!("v{digit}"), + }); + } + TimeSeries { + labels, + samples: vec![Sample::default()], + } +} + +/// splitmix64; seeded per encoder so senders don't emit identical values. +fn next_value(state: &mut u64) -> f64 { + *state = state.wrapping_add(0x9E37_79B9_7F4A_7C15); + let mut z = *state; + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^= z >> 31; + (z >> 11) as f64 / (1u64 << 53) as f64 * VALUE_RANGE +} + +/// Builds request bodies pass after pass until the sender hangs up. Labels are +/// built once; each pass only rewrites the sample. +fn encode_loop( + series: Range, + samples_per_request: usize, + start_ms: i64, + step_ms: i64, + tx: mpsc::Sender, +) { + let ids: Vec = series.clone().collect(); + let mut requests: Vec = ids + .chunks(samples_per_request) + .map(|chunk| WriteRequest { + timeseries: chunk.iter().map(|&i| make_series(i)).collect(), + }) + .collect(); + let mut rng = series.start as u64; + let mut encoder = snap::raw::Encoder::new(); + for pass in 0u64.. { + let timestamp = start_ms + pass as i64 * step_ms; + for request in &mut requests { + for ts in &mut request.timeseries { + ts.samples[0] = Sample { + value: next_value(&mut rng), + timestamp, + }; + } + let body = encoder + .compress_vec(&request.encode_to_vec()) + .expect("snappy compression should succeed"); + if tx + .blocking_send((pass, request.timeseries.len() as u64, body)) + .is_err() + { + return; + } + } + } +} + +struct Shared { + client: reqwest::Client, + url: String, + /// Pass each sender is currently on, for the skew bound. + passes: Vec, + acked_samples: AtomicU64, + stop: AtomicBool, +} + +async fn send_loop( + shared: Arc, + idx: usize, + rate: f64, + mut rx: mpsc::Receiver, +) -> Result<(), String> { + let start = Instant::now(); + let mut sent_samples = 0u64; + while let Some((pass, samples, body)) = rx.recv().await { + shared.passes[idx].store(pass, Ordering::Relaxed); + loop { + if shared.stop.load(Ordering::Relaxed) { + return Ok(()); + } + let slowest = shared + .passes + .iter() + .map(|p| p.load(Ordering::Relaxed)) + .min() + .expect("concurrency >= 1"); + if pass <= slowest + MAX_PASS_SKEW { + break; + } + tokio::time::sleep(SKEW_POLL_INTERVAL).await; + } + if rate > 0.0 { + let due = start + Duration::from_secs_f64(sent_samples as f64 / rate); + tokio::time::sleep_until(due.into()).await; + } + let response = shared + .client + .post(&shared.url) + .header("Content-Type", "application/x-protobuf") + .header("Content-Encoding", "snappy") + .body(body) + .send() + .await + .map_err(|e| format!("sender {idx}: request failed: {e}"))?; + if response.status() != reqwest::StatusCode::NO_CONTENT { + return Err(format!("sender {idx}: HTTP {}", response.status())); + } + sent_samples += samples; + shared.acked_samples.fetch_add(samples, Ordering::Relaxed); + } + Ok(()) +} + +fn clock_ticks_per_sec() -> u64 { + let out = std::process::Command::new("getconf") + .arg("CLK_TCK") + .output() + .expect("getconf CLK_TCK should run"); + String::from_utf8(out.stdout) + .expect("getconf output is ASCII") + .trim() + .parse() + .expect("CLK_TCK is an integer") +} + +/// utime + stime of the whole process, in clock ticks. +fn process_cpu_ticks(pid: u32) -> u64 { + let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")) + .unwrap_or_else(|e| panic!("pid {pid} not readable: {e}")); + // Fields after the parenthesised comm; utime/stime are fields 14/15. + let fields: Vec<&str> = stat[stat.rfind(')').expect("stat has comm") + 2..] + .split_whitespace() + .collect(); + let field = |i: usize| -> u64 { fields[i].parse().expect("stat field is an integer") }; + field(11) + field(12) +} + +fn engine_peak_rss_mb(pid: u32) -> f64 { + let status = std::fs::read_to_string(format!("/proc/{pid}/status")) + .unwrap_or_else(|e| panic!("engine pid {pid} not readable: {e}")); + let kb: f64 = status + .lines() + .find_map(|l| l.strip_prefix("VmHWM:")) + .expect("status has VmHWM") + .trim() + .trim_end_matches("kB") + .trim() + .parse() + .expect("VmHWM is a number"); + kb / 1024.0 +} + +#[tokio::main] +async fn main() { + let args = Args::parse(); + assert!(args.num_series > 0 && args.concurrency > 0 && args.samples_per_request > 0); + let concurrency = args.concurrency.min(args.num_series); + let ticks_per_sec = clock_ticks_per_sec(); + let start_ms = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock after epoch") + .as_millis() as i64; + + let shared = Arc::new(Shared { + client: reqwest::Client::new(), + url: format!("http://127.0.0.1:{}/api/v1/write", args.port), + passes: (0..concurrency).map(|_| AtomicU64::new(0)).collect(), + acked_samples: AtomicU64::new(0), + stop: AtomicBool::new(false), + }); + + let mut senders = Vec::with_capacity(concurrency); + for idx in 0..concurrency { + let series = idx * args.num_series / concurrency..(idx + 1) * args.num_series / concurrency; + let rate = args.target_rate * series.len() as f64 / args.num_series as f64; + let (tx, rx) = mpsc::channel(ENCODE_AHEAD); + let step_ms = args.step_ms; + let samples_per_request = args.samples_per_request; + std::thread::spawn(move || encode_loop(series, samples_per_request, start_ms, step_ms, tx)); + senders.push(tokio::spawn(send_loop(shared.clone(), idx, rate, rx))); + } + + tokio::time::sleep(Duration::from_secs(args.warmup_secs)).await; + let acked_0 = shared.acked_samples.load(Ordering::Relaxed); + let ticks_0 = process_cpu_ticks(args.engine_pid); + let sender_ticks_0 = process_cpu_ticks(std::process::id()); + let t0 = Instant::now(); + assert!(acked_0 > 0, "engine acked no samples during warmup"); + + tokio::time::sleep(Duration::from_secs(args.measure_secs)).await; + let acked_1 = shared.acked_samples.load(Ordering::Relaxed); + let ticks_1 = process_cpu_ticks(args.engine_pid); + let sender_ticks_1 = process_cpu_ticks(std::process::id()); + let elapsed = t0.elapsed().as_secs_f64(); + let cores = |ticks: u64| ticks as f64 / ticks_per_sec as f64 / elapsed; + + shared.stop.store(true, Ordering::Relaxed); + for sender in senders { + if let Err(e) = sender.await.expect("sender task panicked") { + panic!("{e}"); + } + } + + println!( + "{}", + serde_json::json!({ + "num_series": args.num_series, + "concurrency": concurrency, + "target_rate": args.target_rate, + "achieved_rate": (acked_1 - acked_0) as f64 / elapsed, + "engine_cpu_cores": cores(ticks_1 - ticks_0), + // Near the sender's core count means the sender, not the engine, + // capped an open-loop run. + "sender_cpu_cores": cores(sender_ticks_1 - sender_ticks_0), + "engine_peak_rss_mb": engine_peak_rss_mb(args.engine_pid), + "measure_secs": elapsed, + }) + ); + // Encoder threads may be parked on a full channel; don't wait for them. + std::process::exit(0); +} diff --git a/asap-query-engine/src/bin/precompute_engine.rs b/asap-query-engine/src/bin/precompute_engine.rs index 8f32d080..af52286c 100644 --- a/asap-query-engine/src/bin/precompute_engine.rs +++ b/asap-query-engine/src/bin/precompute_engine.rs @@ -72,6 +72,11 @@ struct Args { #[arg(long, default_value_t = 5000)] wall_clock_grace_period_ms: i64, + /// Windows the store keeps per aggregation. Without it (and with no + /// inference config to derive it from) the store grows without bound. + #[arg(long)] + num_aggregates_to_retain: Option, + // --- CSV file ingest (alternative to HTTP) --- /// Path to a local CSV file to ingest instead of listening for HTTP writes #[arg(long)] @@ -121,7 +126,13 @@ async fn main() -> Result<(), Box> { let args = Args::parse(); info!("Loading streaming config from: {}", args.streaming_config); - let streaming_config = Arc::new(StreamingConfig::from_yaml_file(&args.streaming_config)?); + let mut streaming_config = StreamingConfig::from_yaml_file(&args.streaming_config)?; + if let Some(retain) = args.num_aggregates_to_retain { + for config in streaming_config.aggregation_configs.values_mut() { + config.num_aggregates_to_retain = Some(retain); + } + } + let streaming_config = Arc::new(streaming_config); info!( "Loaded {} aggregation configs", diff --git a/asap-tools/experiments/microbench/precompute_throughput/HANDOFF.md b/asap-tools/experiments/microbench/precompute_throughput/HANDOFF.md new file mode 100644 index 00000000..1074a283 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/HANDOFF.md @@ -0,0 +1,141 @@ +# Precompute-engine throughput microbenchmark: how to run + +Measures throughput (samples/s) vs engine CPU of the standalone +`precompute_engine` for several StreamingConfigs and input cardinalities. +No Prometheus involved: a dedicated load generator speaks remote-write +directly to the engine. + +## Pieces + +| File | Role | +|---|---| +| `asap-query-engine/src/bin/bench_ingest_sender.rs` | Load generator (separate process). Pre-encodes remote-write bodies on its own threads, 16 senders each owning a disjoint slice of series with one request in flight, optional rate limit. Prints one JSON line: acked samples/s, engine CPU cores, sender CPU cores, engine peak RSS. | +| `asap-query-engine/src/bin/precompute_engine.rs` | Engine under test. Benchmark relies on `--num-aggregates-to-retain` (added for this) and `--wall-clock-grace-period-ms`. | +| `configs/{kll,ddsketch,cms_heap,hydra_kll}.yaml` | The four pipelines (10s tumbling windows). | +| `sweep.py` | Runs one experiment: per point, starts a fresh engine + sender, appends a JSON line to `--out`, engine log to `results/logs/`. | +| `plot.py` | One figure per experiment. `main` is sized for one column of a two-column paper. | + +Experiments in `sweep.py`: + +- `main`: 4 pipelines (+ `raw`, see caveats) x {1K, 10K, 100K, 1M} series, 8 cores. Open-loop saturation run, then 10/25/50/75/90% of it. 120 points, ~1.5 h. +- `fanin`: KLL at 100K series, grouped by all labels / 2 labels / none. 3 points. +- `window`: KLL and DDSketch at 100K, tumbling 10s vs sliding 60s/1s. 4 points. +- `scaling`: KLL and HydraKLL at 1M, 1/2/4/8/14 cores (workers = cores). 10 points. + +Each point = 15s warmup + 30s measurement + startup, ~50s. + +## Where it ran + +- Node: `milindsr@node5.scratch3.cloudmigration-PG0.clemson.cloudlab.us` + (2x 14-core Xeon E5-2683 v3, 256 GB). Socket 0 = even CPUs, socket 1 = odd; + hyperthread sibling of CPU n is n+28. +- Code there: `/scratch/sketch_db_for_prometheus/code` (plain rsync copy, not a + git checkout; no `ASAPQuery/` subdir). Cargo is at `~/.cargo/bin/cargo` (not on + the non-login PATH). +- Results there: `.../asap-tools/experiments/microbench/precompute_throughput/results/`. + Copied locally to the same path in this repo. + +## Steps + +1. Sync only the benchmark files (the rest of the remote tree matched local; + check with `rsync -anci` before overwriting anything else): + + ```bash + H=milindsr@node5.scratch3.cloudmigration-PG0.clemson.cloudlab.us + R=/scratch/sketch_db_for_prometheus/code + rsync -avR asap-query-engine/Cargo.toml \ + asap-query-engine/src/bin/precompute_engine.rs \ + asap-query-engine/src/bin/bench_ingest_sender.rs \ + asap-tools/experiments/microbench/precompute_throughput/{sweep.py,plot.py,configs} \ + $H:$R/ + ``` + +2. Build on the node: + + ```bash + ssh $H "cd $R/asap-query-engine && ~/.cargo/bin/cargo build --release --bin precompute_engine --bin bench_ingest_sender" + ``` + +3. Run in tmux so it survives disconnects (engine on socket 0, one hyperthread + per physical core; sender on socket 1): + + ```bash + ssh $H "cd $R/asap-tools/experiments/microbench/precompute_throughput && mkdir -p results && \ + tmux new-session -d -s pcbench 'for e in fanin window scaling main; do \ + python3 -u sweep.py --bin-dir ../../../../target/release \ + --engine-cpus \$(seq -s, 0 2 26) --sender-cpus 1-55:2 \ + --experiment \$e --out results/\$e.jsonl > results/\$e.out 2>&1; \ + echo EXIT=\$? >> results/\$e.out; done; sleep 86400'" + ``` + + Run `fanin` alone first as a smoke test (~3 min): it fails loudly if a + config is rejected. Progress: `tail results/.out`. `--out` appends, so + move old `.jsonl` files aside before re-running an experiment. + +4. Plot locally after copying results back: + + ```bash + grep -v '"label": "raw"' results/main.jsonl > results/main_noraw.jsonl + python3 plot.py --input results/main_noraw.jsonl --experiment main --out results/main.pdf + python3 plot.py --input results/fanin.jsonl --experiment fanin --out results/fanin.png + python3 plot.py --input results/window.jsonl --experiment window --out results/window.png + python3 plot.py --input results/scaling.jsonl --experiment scaling --out results/scaling.png + ``` + +## Settings that matter, and why (each fixed a real problem) + +- **Engine pinned to N cores for N workers** (`--engine-cpus`, first N used). + `--num-workers` alone doesn't bound CPU: decode/routing run on the async + runtime across every allowed CPU (4 workers used ~16 cores unpinned). +- **`NUM_AGGREGATES_TO_RETAIN = 1`.** The store keeps retain x 4 windows per + key (`per_key.rs` `max_epochs`). At 10, KLL at 100K series hit 34 GB; 1M + series would exceed the node's RAM. The standalone binary otherwise retains + without bound. +- **`--wall-clock-grace-period-ms 0`.** The engine's wall-clock fallback + force-closes panes idle for window+grace of wall time. With per-series + groups at low rates, one pass over 1M series can exceed that, silently + dropping samples that the sender still counts as acked. +- **16 senders always, 2000 samples/request max.** The engine handles each + request mostly serially, so in-flight requests must exceed engine cores. With + 1 sender at 1K series, measured throughput was 0.13 M/s instead of 1.40 M/s. + More than 16 didn't help at 100K (16 vs 50 senders: same 0.73 M/s). +- **Sender lockstep (`MAX_PASS_SKEW = 2`).** Groups span senders and the engine + keeps one watermark per group, so a sender running ahead would make others' + samples late. Skew x step (2s) must stay below `--allowed-lateness-ms` + (5000). +- **Event time advances 1s per pass over all series, independent of wall + clock**, so window closes per sample are constant across send rates. + +## Sanity checks to look at in results + +- `sender_cpu_cores` should be well below the sender's 28 threads; if near it, + the sender is the bottleneck. +- Rate-limited points should hit their target (`achieved_rate` ≈ + `target_rate`). +- `engine_peak_rss_mb` vs node RAM at 1M series (KLL peaked ~11.5 GB). + +## Caveats / known issues + +- **`raw` is not an overhead floor.** `--pass-raw-samples` stores every + sample individually and is ~7x slower than KLL. It's excluded from the main + plot; a `Sum` pipeline would be a real floor. Consider removing `raw` from + `main_experiment` to save ~25 min. +- **Single run per point.** CPU at low load is noisy (curves zigzag at + 1K/10K). Median of 3 runs would fix it (~3x time). +- **Per-series sketches leave cores idle** (KLL/DDSketch saturate at ~5 of 8 + cores at 100K+ series; KLL stops scaling past 8 cores). Not profiled. + Suspect: the store has one RwLock per aggregation id + (`stores/simple_map_store/per_key.rs`), and per-series grouping emits one + output per series per window. Confirm with a discard-output sink or an + off-CPU profile. +- **HydraKLL at 1K series is slow** because saturating a tiny series set makes + event time race, so expensive window emits dominate. Benchmark artifact. +- **HydraKLL scaling drops at 14 cores**: only 10 groups, so at most 10 + workers have work and hashing can stack groups on one worker. +- When killing runs over ssh, don't `pkill -f bench_ingest_sender` inside an + ssh command line that contains that string: it kills the ssh session itself. + +## Superseded results (kept for reference, don't plot) + +`fanin_retain10.*` (retention 10, unpinned), `fanin_28threads.*` (unpinned), +`main_aborted.*` (before the 16-sender fix). diff --git a/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml b/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml new file mode 100644 index 00000000..7661cd5b --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml @@ -0,0 +1,20 @@ +# P5: keyed top-k. 10 groups (l0); each sketch keys on l1..l4. +aggregations: +- aggregationId: 1 + aggregationType: CountMinSketchWithHeap + aggregationSubType: sum + parameters: + depth: 3 + width: 1024 + heapsize: 20 + labels: + grouping: [l0] + aggregated: [l1, l2, l3, l4] + rollup: [] + metric: bench_metric + spatialFilter: '' + windowType: tumbling + windowSizeMs: 10000 + slideIntervalMs: 10000 +metrics: + bench_metric: [l0, l1, l2, l3, l4] diff --git a/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml b/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml new file mode 100644 index 00000000..2c757e1a --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml @@ -0,0 +1,18 @@ +# P4: per-series quantile sketch (DDSketch alternative to P3). +aggregations: +- aggregationId: 1 + aggregationType: DDSketch + aggregationSubType: '' + parameters: + alpha: 0.01 + labels: + grouping: [l0, l1, l2, l3, l4] + aggregated: [] + rollup: [] + metric: bench_metric + spatialFilter: '' + windowType: tumbling + windowSizeMs: 10000 + slideIntervalMs: 10000 +metrics: + bench_metric: [l0, l1, l2, l3, l4] diff --git a/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml b/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml new file mode 100644 index 00000000..1e6513d2 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml @@ -0,0 +1,21 @@ +# P6: keyed quantiles (KLL per CMS cell). 10 groups (l0); keys on l1..l4. +# Params are the planner defaults (asap-planner-rs/src/planner/sketch.rs). +aggregations: +- aggregationId: 1 + aggregationType: HydraKLL + aggregationSubType: '' + parameters: + depth: 3 + width: 1024 + K: 20 + labels: + grouping: [l0] + aggregated: [l1, l2, l3, l4] + rollup: [] + metric: bench_metric + spatialFilter: '' + windowType: tumbling + windowSizeMs: 10000 + slideIntervalMs: 10000 +metrics: + bench_metric: [l0, l1, l2, l3, l4] diff --git a/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml b/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml new file mode 100644 index 00000000..58ee3bcb --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml @@ -0,0 +1,18 @@ +# P3: per-series quantile sketch. +aggregations: +- aggregationId: 1 + aggregationType: DatasketchesKLL + aggregationSubType: '' + parameters: + K: 200 + labels: + grouping: [l0, l1, l2, l3, l4] + aggregated: [] + rollup: [] + metric: bench_metric + spatialFilter: '' + windowType: tumbling + windowSizeMs: 10000 + slideIntervalMs: 10000 +metrics: + bench_metric: [l0, l1, l2, l3, l4] diff --git a/asap-tools/experiments/microbench/precompute_throughput/plot.py b/asap-tools/experiments/microbench/precompute_throughput/plot.py new file mode 100644 index 00000000..e513c824 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/plot.py @@ -0,0 +1,138 @@ +"""Plot sweep.py results. + + python plot.py --input results/main.jsonl --experiment main --out main.pdf +""" + +import argparse +import json +from collections import defaultdict + +import matplotlib.pyplot as plt + +# Fixed per pipeline (color follows the entity, not its rank). Validated +# colorblind-safe; low-contrast slots are backed by markers + legend. +STYLE = { + "kll": ("#2a78d6", "o", "KLL"), + "ddsketch": ("#eb6834", "s", "DDSketch"), + "cms_heap": ("#1baf7a", "^", "CMS+Heap"), + "hydra_kll": ("#eda100", "D", "HydraKLL"), + "raw": ("#8a8a85", "x", "No sketch (raw)"), +} +MSAMPLES = 1e6 +COLUMN_WIDTH_IN = 3.4 # one column of a typical two-column paper + + +def load(path): + with open(path) as f: + return [json.loads(line) for line in f if line.strip()] + + +def style(label): + """Variant labels (e.g. kll_sliding) inherit their base pipeline's style.""" + base = max((k for k in STYLE if label.startswith(k)), key=len) + return STYLE[base] + + +def series_title(n): + return f"{n // 1_000_000}M series" if n >= 1_000_000 else f"{n // 1_000}K series" + + +def plot_main(rows, out): + """2x2 grid sized for one column of a two-column paper.""" + by_series = defaultdict(lambda: defaultdict(list)) + for r in rows: + by_series[r["num_series"]][r["label"]].append(r) + plt.rcParams.update({"font.size": 8, "axes.titlesize": 8, "legend.fontsize": 8}) + fig, axes = plt.subplots( + 2, 2, figsize=(COLUMN_WIDTH_IN, 3.2), sharex=True, sharey=True + ) + for ax, series in zip(axes.flat, sorted(by_series)): + for label, pts in by_series[series].items(): + # Offered-load order; the open-loop saturation run (target 0) is last. + pts.sort(key=lambda r: r["target_rate"] or float("inf")) + color, marker, name = style(label) + ax.plot( + [r["engine_cpu_cores"] for r in pts], + [r["achieved_rate"] / MSAMPLES for r in pts], + color=color, marker=marker, linewidth=1.5, markersize=3.5, label=name, + ) # fmt: skip + ax.set_title(series_title(series), pad=3) + ymax = max(r["achieved_rate"] for r in rows) / MSAMPLES + max_cores = max(r["engine_cpu_cores"] for r in rows) + axes[0][0].set_xlim(0, max_cores * 1.05) + axes[0][0].set_xticks(range(0, int(max_cores) + 1, 2)) + axes[0][0].set_ylim(0, ymax * 1.08) + fig.supxlabel("CPU cores", fontsize=8) + fig.supylabel("Throughput (M samples/s)", fontsize=8) + handles, names = axes[0][0].get_legend_handles_labels() + fig.legend(handles, names, loc="upper center", ncol=2, frameon=False, + handlelength=1.5, columnspacing=1.0, bbox_to_anchor=(0.5, 1.06)) # fmt: skip + finish(fig, axes.flat, out) + + +def plot_bars(rows, out): + rows = sorted(rows, key=lambda r: r["label"]) + fig, ax = plt.subplots(figsize=(5, 0.45 * len(rows) + 1)) + ys = range(len(rows)) + ax.barh( + ys, + [r["achieved_rate"] / MSAMPLES for r in rows], + color=[style(r["label"])[0] for r in rows], + ) + ax.set_yticks(list(ys), [r["label"] for r in rows]) + for y, r in zip(ys, rows): + ax.annotate( + f" {r['engine_cpu_cores']:.1f} cores", + (r["achieved_rate"] / MSAMPLES, y), + va="center", + fontsize=8, + ) + ax.set_xlabel("Saturation throughput (M samples/s)") + ax.margins(x=0.25, y=0.1) # room for the cores annotations + finish(fig, [ax], out) + + +def plot_scaling(rows, out): + by_label = defaultdict(list) + for r in rows: + by_label[r["label"]].append(r) + fig, ax = plt.subplots(figsize=(4, 3)) + for label, pts in by_label.items(): + pts.sort(key=lambda r: r["workers"]) + color, marker, name = style(label) + ax.plot( + [r["workers"] for r in pts], [r["achieved_rate"] / MSAMPLES for r in pts], + color=color, marker=marker, linewidth=2, markersize=6, label=name, + ) # fmt: skip + ax.set_xscale("log", base=2) + ax.set_xticks([r["workers"] for r in rows], [str(r["workers"]) for r in rows]) + ax.set_xlabel("Engine workers") + ax.set_ylabel("Saturation throughput (M samples/s)") + ax.set_ylim(bottom=0) + ax.legend(frameon=False) + finish(fig, [ax], out) + + +def finish(fig, axes, out): + for ax in axes: + ax.grid(alpha=0.3, linewidth=0.5) + ax.spines[["top", "right"]].set_visible(False) + fig.tight_layout(rect=(0, 0, 1, 0.9) if fig.legends else None) + fig.savefig(out, bbox_inches="tight", dpi=300) + print(f"wrote {out}") + + +PLOTS = { + "main": plot_main, + "fanin": plot_bars, + "window": plot_bars, + "scaling": plot_scaling, +} + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--input", required=True) + parser.add_argument("--experiment", required=True, choices=PLOTS) + parser.add_argument("--out", required=True) + args = parser.parse_args() + PLOTS[args.experiment](load(args.input), args.out) diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/fanin.jsonl b/asap-tools/experiments/microbench/precompute_throughput/results/fanin.jsonl new file mode 100644 index 00000000..b1d844dd --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/fanin.jsonl @@ -0,0 +1,3 @@ +{"achieved_rate": 724664.2618134102, "concurrency": 16, "engine_cpu_cores": 5.013361771717589, "engine_peak_rss_mb": 1236.45703125, "measure_secs": 30.001824494, "num_series": 100000, "sender_cpu_cores": 0.7302889197415888, "target_rate": 0.0, "label": "kll_fanin_1to1", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/results/configs/kll_fanin_1to1.yaml"} +{"achieved_rate": 2975635.9641726334, "concurrency": 16, "engine_cpu_cores": 7.572355263400521, "engine_peak_rss_mb": 139.35546875, "measure_secs": 30.001233711, "num_series": 100000, "sender_cpu_cores": 3.296864420736621, "target_rate": 0.0, "label": "kll_fanin_100groups", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/results/configs/kll_fanin_100groups.yaml"} +{"achieved_rate": 3747938.791700137, "concurrency": 16, "engine_cpu_cores": 8.000024807309957, "engine_peak_rss_mb": 38.8125, "measure_secs": 30.001156969, "num_series": 100000, "sender_cpu_cores": 3.745855538708774, "target_rate": 0.0, "label": "kll_fanin_1group", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/results/configs/kll_fanin_1group.yaml"} diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/fanin.out b/asap-tools/experiments/microbench/precompute_throughput/results/fanin.out new file mode 100644 index 00000000..334442a5 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/fanin.out @@ -0,0 +1,7 @@ +[kll_fanin_1to1] series=100000 workers=8 rate=0 + achieved=724664/s cpu=5.01 cores sender_cpu=0.73 cores rss=1236MB +[kll_fanin_100groups] series=100000 workers=8 rate=0 + achieved=2975636/s cpu=7.57 cores sender_cpu=3.30 cores rss=139MB +[kll_fanin_1group] series=100000 workers=8 rate=0 + achieved=3747939/s cpu=8.00 cores sender_cpu=3.75 cores rss=39MB +EXIT=0 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/fanin.png b/asap-tools/experiments/microbench/precompute_throughput/results/fanin.png new file mode 100644 index 0000000000000000000000000000000000000000..03c21dbb657560afb432c1f8f9099351e079ebc8 GIT binary patch literal 15166 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 G?SBAm1OdMQ literal 0 HcmV?d00001 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/main.jsonl b/asap-tools/experiments/microbench/precompute_throughput/results/main.jsonl new file mode 100644 index 00000000..8edf0499 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/main.jsonl @@ -0,0 +1,120 @@ +{"achieved_rate": 1401062.3630118137, "concurrency": 16, "engine_cpu_cores": 7.082756822752075, "engine_peak_rss_mb": 40.9765625, "measure_secs": 30.001030011, "num_series": 1000, "sender_cpu_cores": 4.025528455380338, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 140093.48978548293, "concurrency": 16, "engine_cpu_cores": 1.398601672947624, "engine_peak_rss_mb": 23.47265625, "measure_secs": 30.001394115, "num_series": 1000, "sender_cpu_cores": 0.4039812267904004, "target_rate": 140106.23630118137, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 350281.1904955484, "concurrency": 16, "engine_cpu_cores": 3.4441483884199275, "engine_peak_rss_mb": 25.21484375, "measure_secs": 30.001610949, "num_series": 1000, "sender_cpu_cores": 1.000946250887936, "target_rate": 350265.59075295343, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 700507.99704564, "concurrency": 16, "engine_cpu_cores": 5.419169821806134, "engine_peak_rss_mb": 25.37109375, "measure_secs": 30.000905184, "num_series": 1000, "sender_cpu_cores": 1.9712738544815769, "target_rate": 700531.1815059069, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1050766.547262899, "concurrency": 16, "engine_cpu_cores": 5.1894499253119575, "engine_peak_rss_mb": 27.55078125, "measure_secs": 30.001252973, "num_series": 1000, "sender_cpu_cores": 3.0218737891244274, "target_rate": 1050796.7722588603, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1260933.8494316489, "concurrency": 16, "engine_cpu_cores": 6.116153781406773, "engine_peak_rss_mb": 42.1171875, "measure_secs": 30.00088071, "num_series": 1000, "sender_cpu_cores": 3.565895316011208, "target_rate": 1260956.1267106324, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1239313.2185562507, "concurrency": 16, "engine_cpu_cores": 6.20845151422808, "engine_peak_rss_mb": 37.20703125, "measure_secs": 30.001039643, "num_series": 1000, "sender_cpu_cores": 3.5305443164771733, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 123915.11136071631, "concurrency": 16, "engine_cpu_cores": 1.2552966416819884, "engine_peak_rss_mb": 18.734375, "measure_secs": 30.000876884, "num_series": 1000, "sender_cpu_cores": 0.3603228012900238, "target_rate": 123931.32185562508, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 309862.141839113, "concurrency": 16, "engine_cpu_cores": 3.1165370063649385, "engine_peak_rss_mb": 19.15234375, "measure_secs": 30.001248119, "num_series": 1000, "sender_cpu_cores": 0.8776301537710035, "target_rate": 309828.30463906267, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 619640.4423080456, "concurrency": 16, "engine_cpu_cores": 5.152816572268548, "engine_peak_rss_mb": 21.22265625, "measure_secs": 30.001067927, "num_series": 1000, "sender_cpu_cores": 1.7516043138153319, "target_rate": 619656.6092781253, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 929414.1543222613, "concurrency": 16, "engine_cpu_cores": 5.042138687115671, "engine_peak_rss_mb": 21.3828125, "measure_secs": 30.001158117, "num_series": 1000, "sender_cpu_cores": 2.6048994407224804, "target_rate": 929484.9139171881, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1115415.7726429123, "concurrency": 16, "engine_cpu_cores": 5.514476851388437, "engine_peak_rss_mb": 26.8359375, "measure_secs": 30.001032638, "num_series": 1000, "sender_cpu_cores": 3.1392252772229394, "target_rate": 1115381.8967006255, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1930598.9655821766, "concurrency": 16, "engine_cpu_cores": 7.962054262269834, "engine_peak_rss_mb": 14.69140625, "measure_secs": 30.001051504, "num_series": 1000, "sender_cpu_cores": 5.477808002099152, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 193070.58128530256, "concurrency": 16, "engine_cpu_cores": 1.6282257912450635, "engine_peak_rss_mb": 14.14453125, "measure_secs": 30.001981459, "num_series": 1000, "sender_cpu_cores": 0.5566299020223656, "target_rate": 193059.89655821768, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 482645.83919293067, "concurrency": 16, "engine_cpu_cores": 4.035527082627511, "engine_peak_rss_mb": 14.4453125, "measure_secs": 30.001037664, "num_series": 1000, "sender_cpu_cores": 1.3929518194681068, "target_rate": 482649.74139554414, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 965268.336404305, "concurrency": 16, "engine_cpu_cores": 5.522497336589666, "engine_peak_rss_mb": 14.82421875, "measure_secs": 30.000919856, "num_series": 1000, "sender_cpu_cores": 2.7409159584003393, "target_rate": 965299.4827910883, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1447947.9391554964, "concurrency": 16, "engine_cpu_cores": 6.090798392745961, "engine_peak_rss_mb": 14.87890625, "measure_secs": 30.000993009, "num_series": 1000, "sender_cpu_cores": 4.196194438038576, "target_rate": 1447949.2241866323, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1737541.3052999876, "concurrency": 16, "engine_cpu_cores": 7.218756563556783, "engine_peak_rss_mb": 14.43359375, "measure_secs": 30.001011683, "num_series": 1000, "sender_cpu_cores": 5.036496822059519, "target_rate": 1737539.0690239589, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 635363.1787275816, "concurrency": 16, "engine_cpu_cores": 6.2511153619415545, "engine_peak_rss_mb": 723.23828125, "measure_secs": 30.001046076, "num_series": 1000, "sender_cpu_cores": 1.7456057987889473, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 63563.26602134065, "concurrency": 16, "engine_cpu_cores": 1.1892697072057863, "engine_peak_rss_mb": 566.5390625, "measure_secs": 30.001605005, "num_series": 1000, "sender_cpu_cores": 0.1846567874977594, "target_rate": 63536.31787275817, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 158830.90371288234, "concurrency": 16, "engine_cpu_cores": 2.8009571540385108, "engine_peak_rss_mb": 587.984375, "measure_secs": 30.000458907, "num_series": 1000, "sender_cpu_cores": 0.44299322357695825, "target_rate": 158840.7946818954, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 317673.23826128105, "concurrency": 16, "engine_cpu_cores": 5.118470712157617, "engine_peak_rss_mb": 587.20703125, "measure_secs": 30.001148514, "num_series": 1000, "sender_cpu_cores": 0.9006321870441443, "target_rate": 317681.5893637908, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 476520.8880805265, "concurrency": 16, "engine_cpu_cores": 5.255839939176077, "engine_peak_rss_mb": 616.32421875, "measure_secs": 30.000913617, "num_series": 1000, "sender_cpu_cores": 1.3476256262106088, "target_rate": 476522.3840456862, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 571812.9031464267, "concurrency": 16, "engine_cpu_cores": 5.610820138053437, "engine_peak_rss_mb": 642.07421875, "measure_secs": 30.000961688, "num_series": 1000, "sender_cpu_cores": 1.5916156454111066, "target_rate": 571826.8608548235, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 206635.7768828085, "concurrency": 16, "engine_cpu_cores": 2.7122564628318897, "engine_peak_rss_mb": 28.60546875, "measure_secs": 30.000850257, "num_series": 1000, "sender_cpu_cores": 0.5713171411200515, "target_rate": 0.0, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 20665.839413114958, "concurrency": 16, "engine_cpu_cores": 0.25398983278699355, "engine_peak_rss_mb": 11.34765625, "measure_secs": 30.0012009, "num_series": 1000, "sender_cpu_cores": 0.0626641582204131, "target_rate": 20663.577688280853, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 51664.6197006569, "concurrency": 16, "engine_cpu_cores": 0.6399746440339434, "engine_peak_rss_mb": 11.20703125, "measure_secs": 30.001188608, "num_series": 1000, "sender_cpu_cores": 0.14532757541604135, "target_rate": 51658.94422070213, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 103328.68544718031, "concurrency": 16, "engine_cpu_cores": 1.2852755196268624, "engine_peak_rss_mb": 11.4765625, "measure_secs": 30.001349447, "num_series": 1000, "sender_cpu_cores": 0.2923201843134746, "target_rate": 103317.88844140425, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 154975.6219609241, "concurrency": 16, "engine_cpu_cores": 1.9032898000201675, "engine_peak_rss_mb": 11.80859375, "measure_secs": 30.00068618, "num_series": 1000, "sender_cpu_cores": 0.430990142106143, "target_rate": 154976.83266210638, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 185963.93456512442, "concurrency": 16, "engine_cpu_cores": 2.299299553020664, "engine_peak_rss_mb": 11.41796875, "measure_secs": 30.000440747, "num_series": 1000, "sender_cpu_cores": 0.5179923898802712, "target_rate": 185972.19919452767, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1356776.1047613262, "concurrency": 16, "engine_cpu_cores": 6.888587656173588, "engine_peak_rss_mb": 165.734375, "measure_secs": 30.000344093, "num_series": 10000, "sender_cpu_cores": 1.6426478258793884, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 135659.95561388243, "concurrency": 16, "engine_cpu_cores": 1.295602573639216, "engine_peak_rss_mb": 127.29296875, "measure_secs": 30.00148409, "num_series": 10000, "sender_cpu_cores": 0.17199149163823915, "target_rate": 135677.61047613263, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 339317.2347212069, "concurrency": 16, "engine_cpu_cores": 3.260511974501813, "engine_peak_rss_mb": 136.8515625, "measure_secs": 30.001423324, "num_series": 10000, "sender_cpu_cores": 0.40031434076637473, "target_rate": 339194.02619033155, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 678694.8862630479, "concurrency": 16, "engine_cpu_cores": 5.055078004881861, "engine_peak_rss_mb": 154.9375, "measure_secs": 30.001515279, "num_series": 10000, "sender_cpu_cores": 0.7936265811435916, "target_rate": 678388.0523806631, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1017459.4613936165, "concurrency": 16, "engine_cpu_cores": 5.156566798749933, "engine_peak_rss_mb": 164.3515625, "measure_secs": 30.000581014, "num_series": 10000, "sender_cpu_cores": 1.2416426196085002, "target_rate": 1017582.0785709947, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1220930.8803761164, "concurrency": 16, "engine_cpu_cores": 6.179650156203439, "engine_peak_rss_mb": 160.82421875, "measure_secs": 30.001698367, "num_series": 10000, "sender_cpu_cores": 1.4635838099185166, "target_rate": 1221098.4942851937, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1268864.4643137404, "concurrency": 16, "engine_cpu_cores": 6.338405898309604, "engine_peak_rss_mb": 93.5703125, "measure_secs": 30.00123423, "num_series": 10000, "sender_cpu_cores": 1.511271158126617, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 126658.96719470987, "concurrency": 16, "engine_cpu_cores": 1.193594109274358, "engine_peak_rss_mb": 66.26171875, "measure_secs": 30.00182367, "num_series": 10000, "sender_cpu_cores": 0.15632383056399718, "target_rate": 126886.44643137405, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 316993.9574189178, "concurrency": 16, "engine_cpu_cores": 2.9406106123550924, "engine_peak_rss_mb": 73.25390625, "measure_secs": 30.000571864, "num_series": 10000, "sender_cpu_cores": 0.37399287089802924, "target_rate": 317216.1160784351, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 633938.8507549079, "concurrency": 16, "engine_cpu_cores": 4.760030614902351, "engine_peak_rss_mb": 88.56640625, "measure_secs": 30.001907877, "num_series": 10000, "sender_cpu_cores": 0.7306202022173485, "target_rate": 634432.2321568702, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 951649.7437722407, "concurrency": 16, "engine_cpu_cores": 4.715812902481001, "engine_peak_rss_mb": 91.0703125, "measure_secs": 30.001190235, "num_series": 10000, "sender_cpu_cores": 1.1412880533004628, "target_rate": 951648.3482353053, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1142234.721125731, "concurrency": 16, "engine_cpu_cores": 5.572490490150825, "engine_peak_rss_mb": 96.18359375, "measure_secs": 30.000948462, "num_series": 10000, "sender_cpu_cores": 1.346957415402529, "target_rate": 1141978.0178823664, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2441448.4253568654, "concurrency": 16, "engine_cpu_cores": 7.993293186703595, "engine_peak_rss_mb": 21.65625, "measure_secs": 30.001401725, "num_series": 10000, "sender_cpu_cores": 2.753538009897769, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 244053.1597194978, "concurrency": 16, "engine_cpu_cores": 1.6602697923179768, "engine_peak_rss_mb": 20.94140625, "measure_secs": 30.001148145, "num_series": 10000, "sender_cpu_cores": 0.2859890547698904, "target_rate": 244144.84253568656, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 610316.3143170627, "concurrency": 16, "engine_cpu_cores": 4.143884445434038, "engine_peak_rss_mb": 21.23046875, "measure_secs": 30.000836567, "num_series": 10000, "sender_cpu_cores": 0.717979978721438, "target_rate": 610362.1063392163, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1220785.4068445887, "concurrency": 16, "engine_cpu_cores": 5.220461717952205, "engine_peak_rss_mb": 21.0390625, "measure_secs": 30.001177762, "num_series": 10000, "sender_cpu_cores": 1.366613015170734, "target_rate": 1220724.2126784327, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1831005.9947168515, "concurrency": 16, "engine_cpu_cores": 6.137670920180875, "engine_peak_rss_mb": 21.34375, "measure_secs": 30.001608492, "num_series": 10000, "sender_cpu_cores": 2.1432184216771493, "target_rate": 1831086.3190176492, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2197246.8569295118, "concurrency": 16, "engine_cpu_cores": 7.3322390517072105, "engine_peak_rss_mb": 21.3359375, "measure_secs": 30.001749595, "num_series": 10000, "sender_cpu_cores": 2.564183790562032, "target_rate": 2197303.5828211787, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1725496.0647779645, "concurrency": 16, "engine_cpu_cores": 7.753368145710985, "engine_peak_rss_mb": 766.015625, "measure_secs": 30.001155063, "num_series": 10000, "sender_cpu_cores": 1.9342588603052682, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 172663.750554339, "concurrency": 16, "engine_cpu_cores": 1.4426423019289174, "engine_peak_rss_mb": 551.4453125, "measure_secs": 30.000506669, "num_series": 10000, "sender_cpu_cores": 0.20266324389389598, "target_rate": 172549.60647779645, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 431329.64672646264, "concurrency": 16, "engine_cpu_cores": 3.4974678449462626, "engine_peak_rss_mb": 579.61328125, "measure_secs": 30.00170542, "num_series": 10000, "sender_cpu_cores": 0.49397191901366255, "target_rate": 431374.0161944911, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 862837.1204725292, "concurrency": 16, "engine_cpu_cores": 5.11510877426102, "engine_peak_rss_mb": 592.20703125, "measure_secs": 30.001317034, "num_series": 10000, "sender_cpu_cores": 0.9539581201573726, "target_rate": 862748.0323889822, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1294064.7605830163, "concurrency": 16, "engine_cpu_cores": 5.499499199216752, "engine_peak_rss_mb": 611.46484375, "measure_secs": 30.000913542, "num_series": 10000, "sender_cpu_cores": 1.5029542329394712, "target_rate": 1294122.0485834733, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1552890.3401333166, "concurrency": 16, "engine_cpu_cores": 6.564712564498011, "engine_peak_rss_mb": 640.07421875, "measure_secs": 30.001313548, "num_series": 10000, "sender_cpu_cores": 1.7845885285769156, "target_rate": 1552946.4583001682, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 217410.5223409306, "concurrency": 16, "engine_cpu_cores": 2.534928359375664, "engine_peak_rss_mb": 37.21484375, "measure_secs": 30.000847842, "num_series": 10000, "sender_cpu_cores": 0.25132623050220265, "target_rate": 0.0, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 21665.685418385605, "concurrency": 16, "engine_cpu_cores": 0.2523219055648908, "engine_peak_rss_mb": 21.63671875, "measure_secs": 30.001358713, "num_series": 10000, "sender_cpu_cores": 0.024332231316033064, "target_rate": 21741.052234093062, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 54331.12539608288, "concurrency": 16, "engine_cpu_cores": 0.6373074340939293, "engine_peak_rss_mb": 21.859375, "measure_secs": 30.001219156, "num_series": 10000, "sender_cpu_cores": 0.06166416072561555, "target_rate": 54352.63058523265, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 108892.9187889536, "concurrency": 16, "engine_cpu_cores": 1.296631962009656, "engine_peak_rss_mb": 22.625, "measure_secs": 30.000802957, "num_series": 10000, "sender_cpu_cores": 0.12532997884720581, "target_rate": 108705.2611704653, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 162990.2860234384, "concurrency": 16, "engine_cpu_cores": 1.8402236587636065, "engine_peak_rss_mb": 22.6015625, "measure_secs": 30.001787955, "num_series": 10000, "sender_cpu_cores": 0.18632222880797972, "target_rate": 163057.89175569796, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 195657.79142706783, "concurrency": 16, "engine_cpu_cores": 2.211566347731848, "engine_peak_rss_mb": 23.015625, "measure_secs": 30.001360831, "num_series": 10000, "sender_cpu_cores": 0.22398983958942006, "target_rate": 195669.47010683754, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 709399.390818914, "concurrency": 16, "engine_cpu_cores": 4.973762021237531, "engine_peak_rss_mb": 1249.859375, "measure_secs": 30.001435405, "num_series": 100000, "sender_cpu_cores": 0.697299969737898, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 71063.04302708294, "concurrency": 16, "engine_cpu_cores": 0.7956260961803329, "engine_peak_rss_mb": 1090.796875, "measure_secs": 30.001529757, "num_series": 100000, "sender_cpu_cores": 0.07332959411800304, "target_rate": 70939.93908189141, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 177723.392695265, "concurrency": 16, "engine_cpu_cores": 1.9622235798893946, "engine_peak_rss_mb": 1139.359375, "measure_secs": 30.001677996, "num_series": 100000, "sender_cpu_cores": 0.18898942921645773, "target_rate": 177349.8477047285, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 354384.57133611, "concurrency": 16, "engine_cpu_cores": 3.447516573861349, "engine_peak_rss_mb": 1149.12109375, "measure_secs": 30.001306095, "num_series": 100000, "sender_cpu_cores": 0.3683172980872852, "target_rate": 354699.695409457, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 532828.2350500156, "concurrency": 16, "engine_cpu_cores": 4.1574968413742734, "engine_peak_rss_mb": 1155.68359375, "measure_secs": 30.001225439, "num_series": 100000, "sender_cpu_cores": 0.5393113035631825, "target_rate": 532049.5431141856, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 635659.7204471356, "concurrency": 16, "engine_cpu_cores": 4.568710496654023, "engine_peak_rss_mb": 1194.96484375, "measure_secs": 30.001900996, "num_series": 100000, "sender_cpu_cores": 0.6379595747133436, "target_rate": 638459.4517370226, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 571846.5683795284, "concurrency": 16, "engine_cpu_cores": 4.42444668774928, "engine_peak_rss_mb": 447.23828125, "measure_secs": 30.001491569, "num_series": 100000, "sender_cpu_cores": 0.5666384939862721, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 57730.618527904815, "concurrency": 16, "engine_cpu_cores": 0.6943006835659683, "engine_peak_rss_mb": 415.84765625, "measure_secs": 30.001410762, "num_series": 100000, "sender_cpu_cores": 0.058997225631865775, "target_rate": 57184.65683795284, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 142260.999140206, "concurrency": 16, "engine_cpu_cores": 1.5752705762338648, "engine_peak_rss_mb": 428.91796875, "measure_secs": 30.001195168, "num_series": 100000, "sender_cpu_cores": 0.14866074418118996, "target_rate": 142961.6420948821, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 288785.7672800953, "concurrency": 16, "engine_cpu_cores": 2.8138613196890176, "engine_peak_rss_mb": 440.6640625, "measure_secs": 30.001478541, "num_series": 100000, "sender_cpu_cores": 0.2966520462595624, "target_rate": 285923.2841897642, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 418300.2493718561, "concurrency": 16, "engine_cpu_cores": 3.5528605586315107, "engine_peak_rss_mb": 459.96875, "measure_secs": 30.001177429, "num_series": 100000, "sender_cpu_cores": 0.42198343814874684, "target_rate": 428884.92628464627, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 528089.2948794035, "concurrency": 16, "engine_cpu_cores": 4.060725446637174, "engine_peak_rss_mb": 449.74609375, "measure_secs": 30.002028357, "num_series": 100000, "sender_cpu_cores": 0.5306307897107758, "target_rate": 514661.9115415755, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2328141.8682868565, "concurrency": 16, "engine_cpu_cores": 8.000295088961114, "engine_peak_rss_mb": 34.21875, "measure_secs": 30.001393365, "num_series": 100000, "sender_cpu_cores": 2.263894852271639, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 233324.4373414009, "concurrency": 16, "engine_cpu_cores": 1.6752694601112583, "engine_peak_rss_mb": 32.59375, "measure_secs": 30.001143814, "num_series": 100000, "sender_cpu_cores": 0.23365775796617433, "target_rate": 232814.18682868566, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 582096.2737471947, "concurrency": 16, "engine_cpu_cores": 3.9604145239716937, "engine_peak_rss_mb": 31.75, "measure_secs": 30.001909972, "num_series": 100000, "sender_cpu_cores": 0.5946288091874686, "target_rate": 582035.4670717141, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1164207.9219767456, "concurrency": 16, "engine_cpu_cores": 4.806090823116896, "engine_peak_rss_mb": 34.33984375, "measure_secs": 30.001513768, "num_series": 100000, "sender_cpu_cores": 1.1942730715880323, "target_rate": 1164070.9341434282, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1746063.2957080328, "concurrency": 16, "engine_cpu_cores": 6.181752039210671, "engine_peak_rss_mb": 35.60546875, "measure_secs": 30.001203352, "num_series": 100000, "sender_cpu_cores": 1.8462592766735633, "target_rate": 1746106.4012151423, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2095429.8055418716, "concurrency": 16, "engine_cpu_cores": 7.4302026271528785, "engine_peak_rss_mb": 35.140625, "measure_secs": 30.000527736, "num_series": 100000, "sender_cpu_cores": 2.1846282364344343, "target_rate": 2095327.6814581708, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1940464.8402284107, "concurrency": 16, "engine_cpu_cores": 7.787058471453918, "engine_peak_rss_mb": 681.5546875, "measure_secs": 30.001058918, "num_series": 100000, "sender_cpu_cores": 1.9095992630322531, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 193323.41438580563, "concurrency": 16, "engine_cpu_cores": 1.5072559997458845, "engine_peak_rss_mb": 373.234375, "measure_secs": 30.001539226, "num_series": 100000, "sender_cpu_cores": 0.1966565767028023, "target_rate": 194046.4840228411, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 484717.77686563163, "concurrency": 16, "engine_cpu_cores": 3.573551977565972, "engine_peak_rss_mb": 419.17578125, "measure_secs": 30.000962816, "num_series": 100000, "sender_cpu_cores": 0.4969840498601683, "target_rate": 485116.21005710267, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 970081.8534822376, "concurrency": 16, "engine_cpu_cores": 4.676085185026907, "engine_peak_rss_mb": 490.68359375, "measure_secs": 30.001592026, "num_series": 100000, "sender_cpu_cores": 0.9852810468985342, "target_rate": 970232.4201142053, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1455276.508326856, "concurrency": 16, "engine_cpu_cores": 5.759108454162029, "engine_peak_rss_mb": 527.12109375, "measure_secs": 30.001171427, "num_series": 100000, "sender_cpu_cores": 1.5212739312880832, "target_rate": 1455348.630171308, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1746574.895940434, "concurrency": 16, "engine_cpu_cores": 6.899703307468006, "engine_peak_rss_mb": 530.08984375, "measure_secs": 30.001290023, "num_series": 100000, "sender_cpu_cores": 1.812588723961885, "target_rate": 1746418.3562055696, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 207097.85833201435, "concurrency": 16, "engine_cpu_cores": 2.5506402896452176, "engine_peak_rss_mb": 58.74609375, "measure_secs": 30.00031024, "num_series": 100000, "sender_cpu_cores": 0.19666463289214306, "target_rate": 0.0, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 19998.747943053902, "concurrency": 16, "engine_cpu_cores": 0.24465134983669276, "engine_peak_rss_mb": 33.31640625, "measure_secs": 30.001878203, "num_series": 100000, "sender_cpu_cores": 0.01966543547733634, "target_rate": 20709.785833201437, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 51196.2819434052, "concurrency": 16, "engine_cpu_cores": 0.6062893024417583, "engine_peak_rss_mb": 34.4609375, "measure_secs": 30.002178707, "num_series": 100000, "sender_cpu_cores": 0.05099629646706377, "target_rate": 51774.46458300359, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 103329.81245263787, "concurrency": 16, "engine_cpu_cores": 1.223958294600278, "engine_peak_rss_mb": 36.4140625, "measure_secs": 30.001022226, "num_series": 100000, "sender_cpu_cores": 0.10432977837959886, "target_rate": 103548.92916600718, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 155459.4785002079, "concurrency": 16, "engine_cpu_cores": 1.844581376544062, "engine_peak_rss_mb": 38.1328125, "measure_secs": 30.001387146, "num_series": 100000, "sender_cpu_cores": 0.15632610509562073, "target_rate": 155323.39374901075, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 186659.5257389642, "concurrency": 16, "engine_cpu_cores": 2.2425808735209842, "engine_peak_rss_mb": 38.37109375, "measure_secs": 30.001147693, "num_series": 100000, "sender_cpu_cores": 0.18699284632064092, "target_rate": 186388.07249881292, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 890078.3175236791, "concurrency": 16, "engine_cpu_cores": 5.747419038351077, "engine_peak_rss_mb": 11503.44921875, "measure_secs": 30.001292554, "num_series": 1000000, "sender_cpu_cores": 0.9292932946078294, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 89329.50707064637, "concurrency": 16, "engine_cpu_cores": 1.0202896311315244, "engine_peak_rss_mb": 9719.6953125, "measure_secs": 30.001284994, "num_series": 1000000, "sender_cpu_cores": 0.09099610235181516, "target_rate": 89007.83175236791, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 228523.42462619857, "concurrency": 16, "engine_cpu_cores": 2.4222283062406436, "engine_peak_rss_mb": 10766.3984375, "measure_secs": 30.001300791, "num_series": 1000000, "sender_cpu_cores": 0.23698972419665576, "target_rate": 222519.57938091978, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 462245.1282162439, "concurrency": 16, "engine_cpu_cores": 4.043811577386408, "engine_peak_rss_mb": 11302.48046875, "measure_secs": 30.001397859, "num_series": 1000000, "sender_cpu_cores": 0.4843107667278644, "target_rate": 445039.15876183956, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 667352.7938435884, "concurrency": 16, "engine_cpu_cores": 4.805993374503397, "engine_peak_rss_mb": 11264.828125, "measure_secs": 30.002122093, "num_series": 1000000, "sender_cpu_cores": 0.6852848587266096, "target_rate": 667558.7381427593, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 844365.8580946735, "concurrency": 16, "engine_cpu_cores": 5.566774907642168, "engine_peak_rss_mb": 11218.328125, "measure_secs": 30.001213049, "num_series": 1000000, "sender_cpu_cores": 0.8696315031458247, "target_rate": 801070.4857713112, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 830502.5798228025, "concurrency": 16, "engine_cpu_cores": 5.537128293472626, "engine_peak_rss_mb": 4018.0, "measure_secs": 30.0011109, "num_series": 1000000, "sender_cpu_cores": 0.8569682664650928, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 82663.31641889275, "concurrency": 16, "engine_cpu_cores": 1.0436243697885208, "engine_peak_rss_mb": 3066.09765625, "measure_secs": 30.001215865, "num_series": 1000000, "sender_cpu_cores": 0.08532987501305057, "target_rate": 83050.25798228025, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 207457.33546392058, "concurrency": 16, "engine_cpu_cores": 2.3288952488534918, "engine_peak_rss_mb": 3750.0703125, "measure_secs": 30.001349367, "num_series": 1000000, "sender_cpu_cores": 0.21432369328936524, "target_rate": 207625.6449557006, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 398583.26366147824, "concurrency": 16, "engine_cpu_cores": 3.6518466605411906, "engine_peak_rss_mb": 3983.68359375, "measure_secs": 30.001259687, "num_series": 1000000, "sender_cpu_cores": 0.4183157684354869, "target_rate": 415251.2899114012, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 607306.6306883321, "concurrency": 16, "engine_cpu_cores": 4.501802060415265, "engine_peak_rss_mb": 3999.2109375, "measure_secs": 30.001319069, "num_series": 1000000, "sender_cpu_cores": 0.6313055754795286, "target_rate": 622876.9348671018, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 845941.75292754, "concurrency": 16, "engine_cpu_cores": 5.488396896591688, "engine_peak_rss_mb": 3969.19140625, "measure_secs": 30.001474584, "num_series": 1000000, "sender_cpu_cores": 0.8662907527172231, "target_rate": 747452.3218405222, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2313963.044391897, "concurrency": 16, "engine_cpu_cores": 7.9994236761730795, "engine_peak_rss_mb": 33.98828125, "measure_secs": 30.00091128, "num_series": 1000000, "sender_cpu_cores": 2.231932202827407, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 231189.23125184613, "concurrency": 16, "engine_cpu_cores": 1.7075871275997803, "engine_peak_rss_mb": 32.28125, "measure_secs": 30.001397394, "num_series": 1000000, "sender_cpu_cores": 0.22098970634367643, "target_rate": 231396.30443918973, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 578646.2155541821, "concurrency": 16, "engine_cpu_cores": 3.93386096542077, "engine_peak_rss_mb": 32.8125, "measure_secs": 30.001060291, "num_series": 1000000, "sender_cpu_cores": 0.5659799965501159, "target_rate": 578490.7610979743, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1157007.2758633865, "concurrency": 16, "engine_cpu_cores": 4.764088785986225, "engine_peak_rss_mb": 34.40234375, "measure_secs": 30.001539942, "num_series": 1000000, "sender_cpu_cores": 1.1362750067464522, "target_rate": 1156981.5221959485, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1735382.7909886907, "concurrency": 16, "engine_cpu_cores": 6.281696388862336, "engine_peak_rss_mb": 33.1484375, "measure_secs": 30.00144998, "num_series": 1000000, "sender_cpu_cores": 1.7392492707780784, "target_rate": 1735472.283293923, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2082858.5533652639, "concurrency": 16, "engine_cpu_cores": 7.544395803493372, "engine_peak_rss_mb": 35.55078125, "measure_secs": 30.001077077, "num_series": 1000000, "sender_cpu_cores": 2.066925792058955, "target_rate": 2082566.7399527074, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2115471.185517008, "concurrency": 16, "engine_cpu_cores": 7.998161378462409, "engine_peak_rss_mb": 397.796875, "measure_secs": 30.000644979, "num_series": 1000000, "sender_cpu_cores": 2.0356229021992056, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 211592.17241559824, "concurrency": 16, "engine_cpu_cores": 1.633939554475839, "engine_peak_rss_mb": 299.90625, "measure_secs": 30.001109812, "num_series": 1000000, "sender_cpu_cores": 0.2053257375677513, "target_rate": 211547.1185517008, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 529038.6710159085, "concurrency": 16, "engine_cpu_cores": 3.760134354668891, "engine_peak_rss_mb": 347.2109375, "measure_secs": 30.001587539, "num_series": 1000000, "sender_cpu_cores": 0.5199724841134181, "target_rate": 528867.796379252, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1058089.458595843, "concurrency": 16, "engine_cpu_cores": 4.689138893499975, "engine_peak_rss_mb": 349.1875, "measure_secs": 30.00124398, "num_series": 1000000, "sender_cpu_cores": 1.039956877148132, "target_rate": 1057735.592758504, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1586630.8051612193, "concurrency": 16, "engine_cpu_cores": 6.263858422392779, "engine_peak_rss_mb": 362.66796875, "measure_secs": 30.000678069, "num_series": 1000000, "sender_cpu_cores": 1.578964311774936, "target_rate": 1586603.389137756, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1903699.4978020424, "concurrency": 16, "engine_cpu_cores": 7.538268698093461, "engine_peak_rss_mb": 382.3984375, "measure_secs": 30.001583793000002, "num_series": 1000000, "sender_cpu_cores": 1.8922334364642988, "target_rate": 1903924.066965307, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 206461.8317090814, "concurrency": 16, "engine_cpu_cores": 2.597939161027737, "engine_peak_rss_mb": 54.5, "measure_secs": 30.000702545, "num_series": 1000000, "sender_cpu_cores": 0.18932889959760774, "target_rate": 0.0, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 21199.19509412123, "concurrency": 16, "engine_cpu_cores": 0.26165673190071015, "engine_peak_rss_mb": 32.7421875, "measure_secs": 30.001139061, "num_series": 1000000, "sender_cpu_cores": 0.0193325992996703, "target_rate": 20646.18317090814, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 51664.97091899117, "concurrency": 16, "engine_cpu_cores": 0.6256461317093317, "engine_peak_rss_mb": 34.49609375, "measure_secs": 30.00098466, "num_series": 1000000, "sender_cpu_cores": 0.04999835895386241, "target_rate": 51615.45792727035, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 103729.42498839744, "concurrency": 16, "engine_cpu_cores": 1.2662856218859957, "engine_peak_rss_mb": 36.27734375, "measure_secs": 30.001130348, "num_series": 1000000, "sender_cpu_cores": 0.09832962844337162, "target_rate": 103230.9158545407, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 155257.57927494362, "concurrency": 16, "engine_cpu_cores": 1.894222462472101, "engine_peak_rss_mb": 39.01171875, "measure_secs": 30.001755932, "num_series": 1000000, "sender_cpu_cores": 0.14699139643677575, "target_rate": 154846.37378181104, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 185722.94275995315, "concurrency": 16, "engine_cpu_cores": 2.2265420991322453, "engine_peak_rss_mb": 40.2734375, "measure_secs": 30.001678399, "num_series": 1000000, "sender_cpu_cores": 0.1806565595403708, "target_rate": 185815.64853817326, "label": "raw", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/main.out b/asap-tools/experiments/microbench/precompute_throughput/results/main.out new file mode 100644 index 00000000..6d416731 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/main.out @@ -0,0 +1,241 @@ +[kll] series=1000 workers=8 rate=0 + achieved=1401062/s cpu=7.08 cores sender_cpu=4.03 cores rss=41MB +[kll] series=1000 workers=8 rate=140106 + achieved=140093/s cpu=1.40 cores sender_cpu=0.40 cores rss=23MB +[kll] series=1000 workers=8 rate=350266 + achieved=350281/s cpu=3.44 cores sender_cpu=1.00 cores rss=25MB +[kll] series=1000 workers=8 rate=700531 + achieved=700508/s cpu=5.42 cores sender_cpu=1.97 cores rss=25MB +[kll] series=1000 workers=8 rate=1050797 + achieved=1050767/s cpu=5.19 cores sender_cpu=3.02 cores rss=28MB +[kll] series=1000 workers=8 rate=1260956 + achieved=1260934/s cpu=6.12 cores sender_cpu=3.57 cores rss=42MB +[ddsketch] series=1000 workers=8 rate=0 + achieved=1239313/s cpu=6.21 cores sender_cpu=3.53 cores rss=37MB +[ddsketch] series=1000 workers=8 rate=123931 + achieved=123915/s cpu=1.26 cores sender_cpu=0.36 cores rss=19MB +[ddsketch] series=1000 workers=8 rate=309828 + achieved=309862/s cpu=3.12 cores sender_cpu=0.88 cores rss=19MB +[ddsketch] series=1000 workers=8 rate=619657 + achieved=619640/s cpu=5.15 cores sender_cpu=1.75 cores rss=21MB +[ddsketch] series=1000 workers=8 rate=929485 + achieved=929414/s cpu=5.04 cores sender_cpu=2.60 cores rss=21MB +[ddsketch] series=1000 workers=8 rate=1115382 + achieved=1115416/s cpu=5.51 cores sender_cpu=3.14 cores rss=27MB +[cms_heap] series=1000 workers=8 rate=0 + achieved=1930599/s cpu=7.96 cores sender_cpu=5.48 cores rss=15MB +[cms_heap] series=1000 workers=8 rate=193060 + achieved=193071/s cpu=1.63 cores sender_cpu=0.56 cores rss=14MB +[cms_heap] series=1000 workers=8 rate=482650 + achieved=482646/s cpu=4.04 cores sender_cpu=1.39 cores rss=14MB +[cms_heap] series=1000 workers=8 rate=965299 + achieved=965268/s cpu=5.52 cores sender_cpu=2.74 cores rss=15MB +[cms_heap] series=1000 workers=8 rate=1447949 + achieved=1447948/s cpu=6.09 cores sender_cpu=4.20 cores rss=15MB +[cms_heap] series=1000 workers=8 rate=1737539 + achieved=1737541/s cpu=7.22 cores sender_cpu=5.04 cores rss=14MB +[hydra_kll] series=1000 workers=8 rate=0 + achieved=635363/s cpu=6.25 cores sender_cpu=1.75 cores rss=723MB +[hydra_kll] series=1000 workers=8 rate=63536 + achieved=63563/s cpu=1.19 cores sender_cpu=0.18 cores rss=567MB +[hydra_kll] series=1000 workers=8 rate=158841 + achieved=158831/s cpu=2.80 cores sender_cpu=0.44 cores rss=588MB +[hydra_kll] series=1000 workers=8 rate=317682 + achieved=317673/s cpu=5.12 cores sender_cpu=0.90 cores rss=587MB +[hydra_kll] series=1000 workers=8 rate=476522 + achieved=476521/s cpu=5.26 cores sender_cpu=1.35 cores rss=616MB +[hydra_kll] series=1000 workers=8 rate=571827 + achieved=571813/s cpu=5.61 cores sender_cpu=1.59 cores rss=642MB +[raw] series=1000 workers=8 rate=0 + achieved=206636/s cpu=2.71 cores sender_cpu=0.57 cores rss=29MB +[raw] series=1000 workers=8 rate=20664 + achieved=20666/s cpu=0.25 cores sender_cpu=0.06 cores rss=11MB +[raw] series=1000 workers=8 rate=51659 + achieved=51665/s cpu=0.64 cores sender_cpu=0.15 cores rss=11MB +[raw] series=1000 workers=8 rate=103318 + achieved=103329/s cpu=1.29 cores sender_cpu=0.29 cores rss=11MB +[raw] series=1000 workers=8 rate=154977 + achieved=154976/s cpu=1.90 cores sender_cpu=0.43 cores rss=12MB +[raw] series=1000 workers=8 rate=185972 + achieved=185964/s cpu=2.30 cores sender_cpu=0.52 cores rss=11MB +[kll] series=10000 workers=8 rate=0 + achieved=1356776/s cpu=6.89 cores sender_cpu=1.64 cores rss=166MB +[kll] series=10000 workers=8 rate=135678 + achieved=135660/s cpu=1.30 cores sender_cpu=0.17 cores rss=127MB +[kll] series=10000 workers=8 rate=339194 + achieved=339317/s cpu=3.26 cores sender_cpu=0.40 cores rss=137MB +[kll] series=10000 workers=8 rate=678388 + achieved=678695/s cpu=5.06 cores sender_cpu=0.79 cores rss=155MB +[kll] series=10000 workers=8 rate=1017582 + achieved=1017459/s cpu=5.16 cores sender_cpu=1.24 cores rss=164MB +[kll] series=10000 workers=8 rate=1221098 + achieved=1220931/s cpu=6.18 cores sender_cpu=1.46 cores rss=161MB +[ddsketch] series=10000 workers=8 rate=0 + achieved=1268864/s cpu=6.34 cores sender_cpu=1.51 cores rss=94MB +[ddsketch] series=10000 workers=8 rate=126886 + achieved=126659/s cpu=1.19 cores sender_cpu=0.16 cores rss=66MB +[ddsketch] series=10000 workers=8 rate=317216 + achieved=316994/s cpu=2.94 cores sender_cpu=0.37 cores rss=73MB +[ddsketch] series=10000 workers=8 rate=634432 + achieved=633939/s cpu=4.76 cores sender_cpu=0.73 cores rss=89MB +[ddsketch] series=10000 workers=8 rate=951648 + achieved=951650/s cpu=4.72 cores sender_cpu=1.14 cores rss=91MB +[ddsketch] series=10000 workers=8 rate=1141978 + achieved=1142235/s cpu=5.57 cores sender_cpu=1.35 cores rss=96MB +[cms_heap] series=10000 workers=8 rate=0 + achieved=2441448/s cpu=7.99 cores sender_cpu=2.75 cores rss=22MB +[cms_heap] series=10000 workers=8 rate=244145 + achieved=244053/s cpu=1.66 cores sender_cpu=0.29 cores rss=21MB +[cms_heap] series=10000 workers=8 rate=610362 + achieved=610316/s cpu=4.14 cores sender_cpu=0.72 cores rss=21MB +[cms_heap] series=10000 workers=8 rate=1220724 + achieved=1220785/s cpu=5.22 cores sender_cpu=1.37 cores rss=21MB +[cms_heap] series=10000 workers=8 rate=1831086 + achieved=1831006/s cpu=6.14 cores sender_cpu=2.14 cores rss=21MB +[cms_heap] series=10000 workers=8 rate=2197304 + achieved=2197247/s cpu=7.33 cores sender_cpu=2.56 cores rss=21MB +[hydra_kll] series=10000 workers=8 rate=0 + achieved=1725496/s cpu=7.75 cores sender_cpu=1.93 cores rss=766MB +[hydra_kll] series=10000 workers=8 rate=172550 + achieved=172664/s cpu=1.44 cores sender_cpu=0.20 cores rss=551MB +[hydra_kll] series=10000 workers=8 rate=431374 + achieved=431330/s cpu=3.50 cores sender_cpu=0.49 cores rss=580MB +[hydra_kll] series=10000 workers=8 rate=862748 + achieved=862837/s cpu=5.12 cores sender_cpu=0.95 cores rss=592MB +[hydra_kll] series=10000 workers=8 rate=1294122 + achieved=1294065/s cpu=5.50 cores sender_cpu=1.50 cores rss=611MB +[hydra_kll] series=10000 workers=8 rate=1552946 + achieved=1552890/s cpu=6.56 cores sender_cpu=1.78 cores rss=640MB +[raw] series=10000 workers=8 rate=0 + achieved=217411/s cpu=2.53 cores sender_cpu=0.25 cores rss=37MB +[raw] series=10000 workers=8 rate=21741 + achieved=21666/s cpu=0.25 cores sender_cpu=0.02 cores rss=22MB +[raw] series=10000 workers=8 rate=54353 + achieved=54331/s cpu=0.64 cores sender_cpu=0.06 cores rss=22MB +[raw] series=10000 workers=8 rate=108705 + achieved=108893/s cpu=1.30 cores sender_cpu=0.13 cores rss=23MB +[raw] series=10000 workers=8 rate=163058 + achieved=162990/s cpu=1.84 cores sender_cpu=0.19 cores rss=23MB +[raw] series=10000 workers=8 rate=195669 + achieved=195658/s cpu=2.21 cores sender_cpu=0.22 cores rss=23MB +[kll] series=100000 workers=8 rate=0 + achieved=709399/s cpu=4.97 cores sender_cpu=0.70 cores rss=1250MB +[kll] series=100000 workers=8 rate=70940 + achieved=71063/s cpu=0.80 cores sender_cpu=0.07 cores rss=1091MB +[kll] series=100000 workers=8 rate=177350 + achieved=177723/s cpu=1.96 cores sender_cpu=0.19 cores rss=1139MB +[kll] series=100000 workers=8 rate=354700 + achieved=354385/s cpu=3.45 cores sender_cpu=0.37 cores rss=1149MB +[kll] series=100000 workers=8 rate=532050 + achieved=532828/s cpu=4.16 cores sender_cpu=0.54 cores rss=1156MB +[kll] series=100000 workers=8 rate=638459 + achieved=635660/s cpu=4.57 cores sender_cpu=0.64 cores rss=1195MB +[ddsketch] series=100000 workers=8 rate=0 + achieved=571847/s cpu=4.42 cores sender_cpu=0.57 cores rss=447MB +[ddsketch] series=100000 workers=8 rate=57185 + achieved=57731/s cpu=0.69 cores sender_cpu=0.06 cores rss=416MB +[ddsketch] series=100000 workers=8 rate=142962 + achieved=142261/s cpu=1.58 cores sender_cpu=0.15 cores rss=429MB +[ddsketch] series=100000 workers=8 rate=285923 + achieved=288786/s cpu=2.81 cores sender_cpu=0.30 cores rss=441MB +[ddsketch] series=100000 workers=8 rate=428885 + achieved=418300/s cpu=3.55 cores sender_cpu=0.42 cores rss=460MB +[ddsketch] series=100000 workers=8 rate=514662 + achieved=528089/s cpu=4.06 cores sender_cpu=0.53 cores rss=450MB +[cms_heap] series=100000 workers=8 rate=0 + achieved=2328142/s cpu=8.00 cores sender_cpu=2.26 cores rss=34MB +[cms_heap] series=100000 workers=8 rate=232814 + achieved=233324/s cpu=1.68 cores sender_cpu=0.23 cores rss=33MB +[cms_heap] series=100000 workers=8 rate=582035 + achieved=582096/s cpu=3.96 cores sender_cpu=0.59 cores rss=32MB +[cms_heap] series=100000 workers=8 rate=1164071 + achieved=1164208/s cpu=4.81 cores sender_cpu=1.19 cores rss=34MB +[cms_heap] series=100000 workers=8 rate=1746106 + achieved=1746063/s cpu=6.18 cores sender_cpu=1.85 cores rss=36MB +[cms_heap] series=100000 workers=8 rate=2095328 + achieved=2095430/s cpu=7.43 cores sender_cpu=2.18 cores rss=35MB +[hydra_kll] series=100000 workers=8 rate=0 + achieved=1940465/s cpu=7.79 cores sender_cpu=1.91 cores rss=682MB +[hydra_kll] series=100000 workers=8 rate=194046 + achieved=193323/s cpu=1.51 cores sender_cpu=0.20 cores rss=373MB +[hydra_kll] series=100000 workers=8 rate=485116 + achieved=484718/s cpu=3.57 cores sender_cpu=0.50 cores rss=419MB +[hydra_kll] series=100000 workers=8 rate=970232 + achieved=970082/s cpu=4.68 cores sender_cpu=0.99 cores rss=491MB +[hydra_kll] series=100000 workers=8 rate=1455349 + achieved=1455277/s cpu=5.76 cores sender_cpu=1.52 cores rss=527MB +[hydra_kll] series=100000 workers=8 rate=1746418 + achieved=1746575/s cpu=6.90 cores sender_cpu=1.81 cores rss=530MB +[raw] series=100000 workers=8 rate=0 + achieved=207098/s cpu=2.55 cores sender_cpu=0.20 cores rss=59MB +[raw] series=100000 workers=8 rate=20710 + achieved=19999/s cpu=0.24 cores sender_cpu=0.02 cores rss=33MB +[raw] series=100000 workers=8 rate=51774 + achieved=51196/s cpu=0.61 cores sender_cpu=0.05 cores rss=34MB +[raw] series=100000 workers=8 rate=103549 + achieved=103330/s cpu=1.22 cores sender_cpu=0.10 cores rss=36MB +[raw] series=100000 workers=8 rate=155323 + achieved=155459/s cpu=1.84 cores sender_cpu=0.16 cores rss=38MB +[raw] series=100000 workers=8 rate=186388 + achieved=186660/s cpu=2.24 cores sender_cpu=0.19 cores rss=38MB +[kll] series=1000000 workers=8 rate=0 + achieved=890078/s cpu=5.75 cores sender_cpu=0.93 cores rss=11503MB +[kll] series=1000000 workers=8 rate=89008 + achieved=89330/s cpu=1.02 cores sender_cpu=0.09 cores rss=9720MB +[kll] series=1000000 workers=8 rate=222520 + achieved=228523/s cpu=2.42 cores sender_cpu=0.24 cores rss=10766MB +[kll] series=1000000 workers=8 rate=445039 + achieved=462245/s cpu=4.04 cores sender_cpu=0.48 cores rss=11302MB +[kll] series=1000000 workers=8 rate=667559 + achieved=667353/s cpu=4.81 cores sender_cpu=0.69 cores rss=11265MB +[kll] series=1000000 workers=8 rate=801070 + achieved=844366/s cpu=5.57 cores sender_cpu=0.87 cores rss=11218MB +[ddsketch] series=1000000 workers=8 rate=0 + achieved=830503/s cpu=5.54 cores sender_cpu=0.86 cores rss=4018MB +[ddsketch] series=1000000 workers=8 rate=83050 + achieved=82663/s cpu=1.04 cores sender_cpu=0.09 cores rss=3066MB +[ddsketch] series=1000000 workers=8 rate=207626 + achieved=207457/s cpu=2.33 cores sender_cpu=0.21 cores rss=3750MB +[ddsketch] series=1000000 workers=8 rate=415251 + achieved=398583/s cpu=3.65 cores sender_cpu=0.42 cores rss=3984MB +[ddsketch] series=1000000 workers=8 rate=622877 + achieved=607307/s cpu=4.50 cores sender_cpu=0.63 cores rss=3999MB +[ddsketch] series=1000000 workers=8 rate=747452 + achieved=845942/s cpu=5.49 cores sender_cpu=0.87 cores rss=3969MB +[cms_heap] series=1000000 workers=8 rate=0 + achieved=2313963/s cpu=8.00 cores sender_cpu=2.23 cores rss=34MB +[cms_heap] series=1000000 workers=8 rate=231396 + achieved=231189/s cpu=1.71 cores sender_cpu=0.22 cores rss=32MB +[cms_heap] series=1000000 workers=8 rate=578491 + achieved=578646/s cpu=3.93 cores sender_cpu=0.57 cores rss=33MB +[cms_heap] series=1000000 workers=8 rate=1156982 + achieved=1157007/s cpu=4.76 cores sender_cpu=1.14 cores rss=34MB +[cms_heap] series=1000000 workers=8 rate=1735472 + achieved=1735383/s cpu=6.28 cores sender_cpu=1.74 cores rss=33MB +[cms_heap] series=1000000 workers=8 rate=2082567 + achieved=2082859/s cpu=7.54 cores sender_cpu=2.07 cores rss=36MB +[hydra_kll] series=1000000 workers=8 rate=0 + achieved=2115471/s cpu=8.00 cores sender_cpu=2.04 cores rss=398MB +[hydra_kll] series=1000000 workers=8 rate=211547 + achieved=211592/s cpu=1.63 cores sender_cpu=0.21 cores rss=300MB +[hydra_kll] series=1000000 workers=8 rate=528868 + achieved=529039/s cpu=3.76 cores sender_cpu=0.52 cores rss=347MB +[hydra_kll] series=1000000 workers=8 rate=1057736 + achieved=1058089/s cpu=4.69 cores sender_cpu=1.04 cores rss=349MB +[hydra_kll] series=1000000 workers=8 rate=1586603 + achieved=1586631/s cpu=6.26 cores sender_cpu=1.58 cores rss=363MB +[hydra_kll] series=1000000 workers=8 rate=1903924 + achieved=1903699/s cpu=7.54 cores sender_cpu=1.89 cores rss=382MB +[raw] series=1000000 workers=8 rate=0 + achieved=206462/s cpu=2.60 cores sender_cpu=0.19 cores rss=54MB +[raw] series=1000000 workers=8 rate=20646 + achieved=21199/s cpu=0.26 cores sender_cpu=0.02 cores rss=33MB +[raw] series=1000000 workers=8 rate=51615 + achieved=51665/s cpu=0.63 cores sender_cpu=0.05 cores rss=34MB +[raw] series=1000000 workers=8 rate=103231 + achieved=103729/s cpu=1.27 cores sender_cpu=0.10 cores rss=36MB +[raw] series=1000000 workers=8 rate=154846 + achieved=155258/s cpu=1.89 cores sender_cpu=0.15 cores rss=39MB +[raw] series=1000000 workers=8 rate=185816 + achieved=185723/s cpu=2.23 cores sender_cpu=0.18 cores rss=40MB +EXIT=0 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/main.pdf b/asap-tools/experiments/microbench/precompute_throughput/results/main.pdf new file mode 100644 index 0000000000000000000000000000000000000000..99a1895feb8fa4cb2602dc9092a79df2e7eb132e GIT binary patch literal 22279 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 NL&nJ|cUGS4{{Y|Vs%`)P literal 0 HcmV?d00001 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/main.png b/asap-tools/experiments/microbench/precompute_throughput/results/main.png new file mode 100644 index 0000000000000000000000000000000000000000..062b788c513c2e53a3a6c75067f24cdc75789fa6 GIT binary patch literal 103881 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 literal 0 HcmV?d00001 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/main_noraw.jsonl b/asap-tools/experiments/microbench/precompute_throughput/results/main_noraw.jsonl new file mode 100644 index 00000000..4139d518 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/main_noraw.jsonl @@ -0,0 +1,96 @@ +{"achieved_rate": 1401062.3630118137, "concurrency": 16, "engine_cpu_cores": 7.082756822752075, "engine_peak_rss_mb": 40.9765625, "measure_secs": 30.001030011, "num_series": 1000, "sender_cpu_cores": 4.025528455380338, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 140093.48978548293, "concurrency": 16, "engine_cpu_cores": 1.398601672947624, "engine_peak_rss_mb": 23.47265625, "measure_secs": 30.001394115, "num_series": 1000, "sender_cpu_cores": 0.4039812267904004, "target_rate": 140106.23630118137, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 350281.1904955484, "concurrency": 16, "engine_cpu_cores": 3.4441483884199275, "engine_peak_rss_mb": 25.21484375, "measure_secs": 30.001610949, "num_series": 1000, "sender_cpu_cores": 1.000946250887936, "target_rate": 350265.59075295343, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 700507.99704564, "concurrency": 16, "engine_cpu_cores": 5.419169821806134, "engine_peak_rss_mb": 25.37109375, "measure_secs": 30.000905184, "num_series": 1000, "sender_cpu_cores": 1.9712738544815769, "target_rate": 700531.1815059069, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1050766.547262899, "concurrency": 16, "engine_cpu_cores": 5.1894499253119575, "engine_peak_rss_mb": 27.55078125, "measure_secs": 30.001252973, "num_series": 1000, "sender_cpu_cores": 3.0218737891244274, "target_rate": 1050796.7722588603, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1260933.8494316489, "concurrency": 16, "engine_cpu_cores": 6.116153781406773, "engine_peak_rss_mb": 42.1171875, "measure_secs": 30.00088071, "num_series": 1000, "sender_cpu_cores": 3.565895316011208, "target_rate": 1260956.1267106324, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1239313.2185562507, "concurrency": 16, "engine_cpu_cores": 6.20845151422808, "engine_peak_rss_mb": 37.20703125, "measure_secs": 30.001039643, "num_series": 1000, "sender_cpu_cores": 3.5305443164771733, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 123915.11136071631, "concurrency": 16, "engine_cpu_cores": 1.2552966416819884, "engine_peak_rss_mb": 18.734375, "measure_secs": 30.000876884, "num_series": 1000, "sender_cpu_cores": 0.3603228012900238, "target_rate": 123931.32185562508, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 309862.141839113, "concurrency": 16, "engine_cpu_cores": 3.1165370063649385, "engine_peak_rss_mb": 19.15234375, "measure_secs": 30.001248119, "num_series": 1000, "sender_cpu_cores": 0.8776301537710035, "target_rate": 309828.30463906267, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 619640.4423080456, "concurrency": 16, "engine_cpu_cores": 5.152816572268548, "engine_peak_rss_mb": 21.22265625, "measure_secs": 30.001067927, "num_series": 1000, "sender_cpu_cores": 1.7516043138153319, "target_rate": 619656.6092781253, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 929414.1543222613, "concurrency": 16, "engine_cpu_cores": 5.042138687115671, "engine_peak_rss_mb": 21.3828125, "measure_secs": 30.001158117, "num_series": 1000, "sender_cpu_cores": 2.6048994407224804, "target_rate": 929484.9139171881, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1115415.7726429123, "concurrency": 16, "engine_cpu_cores": 5.514476851388437, "engine_peak_rss_mb": 26.8359375, "measure_secs": 30.001032638, "num_series": 1000, "sender_cpu_cores": 3.1392252772229394, "target_rate": 1115381.8967006255, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1930598.9655821766, "concurrency": 16, "engine_cpu_cores": 7.962054262269834, "engine_peak_rss_mb": 14.69140625, "measure_secs": 30.001051504, "num_series": 1000, "sender_cpu_cores": 5.477808002099152, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 193070.58128530256, "concurrency": 16, "engine_cpu_cores": 1.6282257912450635, "engine_peak_rss_mb": 14.14453125, "measure_secs": 30.001981459, "num_series": 1000, "sender_cpu_cores": 0.5566299020223656, "target_rate": 193059.89655821768, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 482645.83919293067, "concurrency": 16, "engine_cpu_cores": 4.035527082627511, "engine_peak_rss_mb": 14.4453125, "measure_secs": 30.001037664, "num_series": 1000, "sender_cpu_cores": 1.3929518194681068, "target_rate": 482649.74139554414, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 965268.336404305, "concurrency": 16, "engine_cpu_cores": 5.522497336589666, "engine_peak_rss_mb": 14.82421875, "measure_secs": 30.000919856, "num_series": 1000, "sender_cpu_cores": 2.7409159584003393, "target_rate": 965299.4827910883, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1447947.9391554964, "concurrency": 16, "engine_cpu_cores": 6.090798392745961, "engine_peak_rss_mb": 14.87890625, "measure_secs": 30.000993009, "num_series": 1000, "sender_cpu_cores": 4.196194438038576, "target_rate": 1447949.2241866323, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1737541.3052999876, "concurrency": 16, "engine_cpu_cores": 7.218756563556783, "engine_peak_rss_mb": 14.43359375, "measure_secs": 30.001011683, "num_series": 1000, "sender_cpu_cores": 5.036496822059519, "target_rate": 1737539.0690239589, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 635363.1787275816, "concurrency": 16, "engine_cpu_cores": 6.2511153619415545, "engine_peak_rss_mb": 723.23828125, "measure_secs": 30.001046076, "num_series": 1000, "sender_cpu_cores": 1.7456057987889473, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 63563.26602134065, "concurrency": 16, "engine_cpu_cores": 1.1892697072057863, "engine_peak_rss_mb": 566.5390625, "measure_secs": 30.001605005, "num_series": 1000, "sender_cpu_cores": 0.1846567874977594, "target_rate": 63536.31787275817, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 158830.90371288234, "concurrency": 16, "engine_cpu_cores": 2.8009571540385108, "engine_peak_rss_mb": 587.984375, "measure_secs": 30.000458907, "num_series": 1000, "sender_cpu_cores": 0.44299322357695825, "target_rate": 158840.7946818954, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 317673.23826128105, "concurrency": 16, "engine_cpu_cores": 5.118470712157617, "engine_peak_rss_mb": 587.20703125, "measure_secs": 30.001148514, "num_series": 1000, "sender_cpu_cores": 0.9006321870441443, "target_rate": 317681.5893637908, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 476520.8880805265, "concurrency": 16, "engine_cpu_cores": 5.255839939176077, "engine_peak_rss_mb": 616.32421875, "measure_secs": 30.000913617, "num_series": 1000, "sender_cpu_cores": 1.3476256262106088, "target_rate": 476522.3840456862, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 571812.9031464267, "concurrency": 16, "engine_cpu_cores": 5.610820138053437, "engine_peak_rss_mb": 642.07421875, "measure_secs": 30.000961688, "num_series": 1000, "sender_cpu_cores": 1.5916156454111066, "target_rate": 571826.8608548235, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1356776.1047613262, "concurrency": 16, "engine_cpu_cores": 6.888587656173588, "engine_peak_rss_mb": 165.734375, "measure_secs": 30.000344093, "num_series": 10000, "sender_cpu_cores": 1.6426478258793884, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 135659.95561388243, "concurrency": 16, "engine_cpu_cores": 1.295602573639216, "engine_peak_rss_mb": 127.29296875, "measure_secs": 30.00148409, "num_series": 10000, "sender_cpu_cores": 0.17199149163823915, "target_rate": 135677.61047613263, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 339317.2347212069, "concurrency": 16, "engine_cpu_cores": 3.260511974501813, "engine_peak_rss_mb": 136.8515625, "measure_secs": 30.001423324, "num_series": 10000, "sender_cpu_cores": 0.40031434076637473, "target_rate": 339194.02619033155, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 678694.8862630479, "concurrency": 16, "engine_cpu_cores": 5.055078004881861, "engine_peak_rss_mb": 154.9375, "measure_secs": 30.001515279, "num_series": 10000, "sender_cpu_cores": 0.7936265811435916, "target_rate": 678388.0523806631, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1017459.4613936165, "concurrency": 16, "engine_cpu_cores": 5.156566798749933, "engine_peak_rss_mb": 164.3515625, "measure_secs": 30.000581014, "num_series": 10000, "sender_cpu_cores": 1.2416426196085002, "target_rate": 1017582.0785709947, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1220930.8803761164, "concurrency": 16, "engine_cpu_cores": 6.179650156203439, "engine_peak_rss_mb": 160.82421875, "measure_secs": 30.001698367, "num_series": 10000, "sender_cpu_cores": 1.4635838099185166, "target_rate": 1221098.4942851937, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 1268864.4643137404, "concurrency": 16, "engine_cpu_cores": 6.338405898309604, "engine_peak_rss_mb": 93.5703125, "measure_secs": 30.00123423, "num_series": 10000, "sender_cpu_cores": 1.511271158126617, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 126658.96719470987, "concurrency": 16, "engine_cpu_cores": 1.193594109274358, "engine_peak_rss_mb": 66.26171875, "measure_secs": 30.00182367, "num_series": 10000, "sender_cpu_cores": 0.15632383056399718, "target_rate": 126886.44643137405, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 316993.9574189178, "concurrency": 16, "engine_cpu_cores": 2.9406106123550924, "engine_peak_rss_mb": 73.25390625, "measure_secs": 30.000571864, "num_series": 10000, "sender_cpu_cores": 0.37399287089802924, "target_rate": 317216.1160784351, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 633938.8507549079, "concurrency": 16, "engine_cpu_cores": 4.760030614902351, "engine_peak_rss_mb": 88.56640625, "measure_secs": 30.001907877, "num_series": 10000, "sender_cpu_cores": 0.7306202022173485, "target_rate": 634432.2321568702, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 951649.7437722407, "concurrency": 16, "engine_cpu_cores": 4.715812902481001, "engine_peak_rss_mb": 91.0703125, "measure_secs": 30.001190235, "num_series": 10000, "sender_cpu_cores": 1.1412880533004628, "target_rate": 951648.3482353053, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 1142234.721125731, "concurrency": 16, "engine_cpu_cores": 5.572490490150825, "engine_peak_rss_mb": 96.18359375, "measure_secs": 30.000948462, "num_series": 10000, "sender_cpu_cores": 1.346957415402529, "target_rate": 1141978.0178823664, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2441448.4253568654, "concurrency": 16, "engine_cpu_cores": 7.993293186703595, "engine_peak_rss_mb": 21.65625, "measure_secs": 30.001401725, "num_series": 10000, "sender_cpu_cores": 2.753538009897769, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 244053.1597194978, "concurrency": 16, "engine_cpu_cores": 1.6602697923179768, "engine_peak_rss_mb": 20.94140625, "measure_secs": 30.001148145, "num_series": 10000, "sender_cpu_cores": 0.2859890547698904, "target_rate": 244144.84253568656, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 610316.3143170627, "concurrency": 16, "engine_cpu_cores": 4.143884445434038, "engine_peak_rss_mb": 21.23046875, "measure_secs": 30.000836567, "num_series": 10000, "sender_cpu_cores": 0.717979978721438, "target_rate": 610362.1063392163, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1220785.4068445887, "concurrency": 16, "engine_cpu_cores": 5.220461717952205, "engine_peak_rss_mb": 21.0390625, "measure_secs": 30.001177762, "num_series": 10000, "sender_cpu_cores": 1.366613015170734, "target_rate": 1220724.2126784327, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1831005.9947168515, "concurrency": 16, "engine_cpu_cores": 6.137670920180875, "engine_peak_rss_mb": 21.34375, "measure_secs": 30.001608492, "num_series": 10000, "sender_cpu_cores": 2.1432184216771493, "target_rate": 1831086.3190176492, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2197246.8569295118, "concurrency": 16, "engine_cpu_cores": 7.3322390517072105, "engine_peak_rss_mb": 21.3359375, "measure_secs": 30.001749595, "num_series": 10000, "sender_cpu_cores": 2.564183790562032, "target_rate": 2197303.5828211787, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1725496.0647779645, "concurrency": 16, "engine_cpu_cores": 7.753368145710985, "engine_peak_rss_mb": 766.015625, "measure_secs": 30.001155063, "num_series": 10000, "sender_cpu_cores": 1.9342588603052682, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 172663.750554339, "concurrency": 16, "engine_cpu_cores": 1.4426423019289174, "engine_peak_rss_mb": 551.4453125, "measure_secs": 30.000506669, "num_series": 10000, "sender_cpu_cores": 0.20266324389389598, "target_rate": 172549.60647779645, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 431329.64672646264, "concurrency": 16, "engine_cpu_cores": 3.4974678449462626, "engine_peak_rss_mb": 579.61328125, "measure_secs": 30.00170542, "num_series": 10000, "sender_cpu_cores": 0.49397191901366255, "target_rate": 431374.0161944911, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 862837.1204725292, "concurrency": 16, "engine_cpu_cores": 5.11510877426102, "engine_peak_rss_mb": 592.20703125, "measure_secs": 30.001317034, "num_series": 10000, "sender_cpu_cores": 0.9539581201573726, "target_rate": 862748.0323889822, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1294064.7605830163, "concurrency": 16, "engine_cpu_cores": 5.499499199216752, "engine_peak_rss_mb": 611.46484375, "measure_secs": 30.000913542, "num_series": 10000, "sender_cpu_cores": 1.5029542329394712, "target_rate": 1294122.0485834733, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1552890.3401333166, "concurrency": 16, "engine_cpu_cores": 6.564712564498011, "engine_peak_rss_mb": 640.07421875, "measure_secs": 30.001313548, "num_series": 10000, "sender_cpu_cores": 1.7845885285769156, "target_rate": 1552946.4583001682, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 709399.390818914, "concurrency": 16, "engine_cpu_cores": 4.973762021237531, "engine_peak_rss_mb": 1249.859375, "measure_secs": 30.001435405, "num_series": 100000, "sender_cpu_cores": 0.697299969737898, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 71063.04302708294, "concurrency": 16, "engine_cpu_cores": 0.7956260961803329, "engine_peak_rss_mb": 1090.796875, "measure_secs": 30.001529757, "num_series": 100000, "sender_cpu_cores": 0.07332959411800304, "target_rate": 70939.93908189141, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 177723.392695265, "concurrency": 16, "engine_cpu_cores": 1.9622235798893946, "engine_peak_rss_mb": 1139.359375, "measure_secs": 30.001677996, "num_series": 100000, "sender_cpu_cores": 0.18898942921645773, "target_rate": 177349.8477047285, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 354384.57133611, "concurrency": 16, "engine_cpu_cores": 3.447516573861349, "engine_peak_rss_mb": 1149.12109375, "measure_secs": 30.001306095, "num_series": 100000, "sender_cpu_cores": 0.3683172980872852, "target_rate": 354699.695409457, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 532828.2350500156, "concurrency": 16, "engine_cpu_cores": 4.1574968413742734, "engine_peak_rss_mb": 1155.68359375, "measure_secs": 30.001225439, "num_series": 100000, "sender_cpu_cores": 0.5393113035631825, "target_rate": 532049.5431141856, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 635659.7204471356, "concurrency": 16, "engine_cpu_cores": 4.568710496654023, "engine_peak_rss_mb": 1194.96484375, "measure_secs": 30.001900996, "num_series": 100000, "sender_cpu_cores": 0.6379595747133436, "target_rate": 638459.4517370226, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 571846.5683795284, "concurrency": 16, "engine_cpu_cores": 4.42444668774928, "engine_peak_rss_mb": 447.23828125, "measure_secs": 30.001491569, "num_series": 100000, "sender_cpu_cores": 0.5666384939862721, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 57730.618527904815, "concurrency": 16, "engine_cpu_cores": 0.6943006835659683, "engine_peak_rss_mb": 415.84765625, "measure_secs": 30.001410762, "num_series": 100000, "sender_cpu_cores": 0.058997225631865775, "target_rate": 57184.65683795284, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 142260.999140206, "concurrency": 16, "engine_cpu_cores": 1.5752705762338648, "engine_peak_rss_mb": 428.91796875, "measure_secs": 30.001195168, "num_series": 100000, "sender_cpu_cores": 0.14866074418118996, "target_rate": 142961.6420948821, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 288785.7672800953, "concurrency": 16, "engine_cpu_cores": 2.8138613196890176, "engine_peak_rss_mb": 440.6640625, "measure_secs": 30.001478541, "num_series": 100000, "sender_cpu_cores": 0.2966520462595624, "target_rate": 285923.2841897642, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 418300.2493718561, "concurrency": 16, "engine_cpu_cores": 3.5528605586315107, "engine_peak_rss_mb": 459.96875, "measure_secs": 30.001177429, "num_series": 100000, "sender_cpu_cores": 0.42198343814874684, "target_rate": 428884.92628464627, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 528089.2948794035, "concurrency": 16, "engine_cpu_cores": 4.060725446637174, "engine_peak_rss_mb": 449.74609375, "measure_secs": 30.002028357, "num_series": 100000, "sender_cpu_cores": 0.5306307897107758, "target_rate": 514661.9115415755, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2328141.8682868565, "concurrency": 16, "engine_cpu_cores": 8.000295088961114, "engine_peak_rss_mb": 34.21875, "measure_secs": 30.001393365, "num_series": 100000, "sender_cpu_cores": 2.263894852271639, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 233324.4373414009, "concurrency": 16, "engine_cpu_cores": 1.6752694601112583, "engine_peak_rss_mb": 32.59375, "measure_secs": 30.001143814, "num_series": 100000, "sender_cpu_cores": 0.23365775796617433, "target_rate": 232814.18682868566, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 582096.2737471947, "concurrency": 16, "engine_cpu_cores": 3.9604145239716937, "engine_peak_rss_mb": 31.75, "measure_secs": 30.001909972, "num_series": 100000, "sender_cpu_cores": 0.5946288091874686, "target_rate": 582035.4670717141, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1164207.9219767456, "concurrency": 16, "engine_cpu_cores": 4.806090823116896, "engine_peak_rss_mb": 34.33984375, "measure_secs": 30.001513768, "num_series": 100000, "sender_cpu_cores": 1.1942730715880323, "target_rate": 1164070.9341434282, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1746063.2957080328, "concurrency": 16, "engine_cpu_cores": 6.181752039210671, "engine_peak_rss_mb": 35.60546875, "measure_secs": 30.001203352, "num_series": 100000, "sender_cpu_cores": 1.8462592766735633, "target_rate": 1746106.4012151423, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2095429.8055418716, "concurrency": 16, "engine_cpu_cores": 7.4302026271528785, "engine_peak_rss_mb": 35.140625, "measure_secs": 30.000527736, "num_series": 100000, "sender_cpu_cores": 2.1846282364344343, "target_rate": 2095327.6814581708, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1940464.8402284107, "concurrency": 16, "engine_cpu_cores": 7.787058471453918, "engine_peak_rss_mb": 681.5546875, "measure_secs": 30.001058918, "num_series": 100000, "sender_cpu_cores": 1.9095992630322531, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 193323.41438580563, "concurrency": 16, "engine_cpu_cores": 1.5072559997458845, "engine_peak_rss_mb": 373.234375, "measure_secs": 30.001539226, "num_series": 100000, "sender_cpu_cores": 0.1966565767028023, "target_rate": 194046.4840228411, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 484717.77686563163, "concurrency": 16, "engine_cpu_cores": 3.573551977565972, "engine_peak_rss_mb": 419.17578125, "measure_secs": 30.000962816, "num_series": 100000, "sender_cpu_cores": 0.4969840498601683, "target_rate": 485116.21005710267, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 970081.8534822376, "concurrency": 16, "engine_cpu_cores": 4.676085185026907, "engine_peak_rss_mb": 490.68359375, "measure_secs": 30.001592026, "num_series": 100000, "sender_cpu_cores": 0.9852810468985342, "target_rate": 970232.4201142053, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1455276.508326856, "concurrency": 16, "engine_cpu_cores": 5.759108454162029, "engine_peak_rss_mb": 527.12109375, "measure_secs": 30.001171427, "num_series": 100000, "sender_cpu_cores": 1.5212739312880832, "target_rate": 1455348.630171308, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1746574.895940434, "concurrency": 16, "engine_cpu_cores": 6.899703307468006, "engine_peak_rss_mb": 530.08984375, "measure_secs": 30.001290023, "num_series": 100000, "sender_cpu_cores": 1.812588723961885, "target_rate": 1746418.3562055696, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 890078.3175236791, "concurrency": 16, "engine_cpu_cores": 5.747419038351077, "engine_peak_rss_mb": 11503.44921875, "measure_secs": 30.001292554, "num_series": 1000000, "sender_cpu_cores": 0.9292932946078294, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 89329.50707064637, "concurrency": 16, "engine_cpu_cores": 1.0202896311315244, "engine_peak_rss_mb": 9719.6953125, "measure_secs": 30.001284994, "num_series": 1000000, "sender_cpu_cores": 0.09099610235181516, "target_rate": 89007.83175236791, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 228523.42462619857, "concurrency": 16, "engine_cpu_cores": 2.4222283062406436, "engine_peak_rss_mb": 10766.3984375, "measure_secs": 30.001300791, "num_series": 1000000, "sender_cpu_cores": 0.23698972419665576, "target_rate": 222519.57938091978, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 462245.1282162439, "concurrency": 16, "engine_cpu_cores": 4.043811577386408, "engine_peak_rss_mb": 11302.48046875, "measure_secs": 30.001397859, "num_series": 1000000, "sender_cpu_cores": 0.4843107667278644, "target_rate": 445039.15876183956, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 667352.7938435884, "concurrency": 16, "engine_cpu_cores": 4.805993374503397, "engine_peak_rss_mb": 11264.828125, "measure_secs": 30.002122093, "num_series": 1000000, "sender_cpu_cores": 0.6852848587266096, "target_rate": 667558.7381427593, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 844365.8580946735, "concurrency": 16, "engine_cpu_cores": 5.566774907642168, "engine_peak_rss_mb": 11218.328125, "measure_secs": 30.001213049, "num_series": 1000000, "sender_cpu_cores": 0.8696315031458247, "target_rate": 801070.4857713112, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 830502.5798228025, "concurrency": 16, "engine_cpu_cores": 5.537128293472626, "engine_peak_rss_mb": 4018.0, "measure_secs": 30.0011109, "num_series": 1000000, "sender_cpu_cores": 0.8569682664650928, "target_rate": 0.0, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 82663.31641889275, "concurrency": 16, "engine_cpu_cores": 1.0436243697885208, "engine_peak_rss_mb": 3066.09765625, "measure_secs": 30.001215865, "num_series": 1000000, "sender_cpu_cores": 0.08532987501305057, "target_rate": 83050.25798228025, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 207457.33546392058, "concurrency": 16, "engine_cpu_cores": 2.3288952488534918, "engine_peak_rss_mb": 3750.0703125, "measure_secs": 30.001349367, "num_series": 1000000, "sender_cpu_cores": 0.21432369328936524, "target_rate": 207625.6449557006, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 398583.26366147824, "concurrency": 16, "engine_cpu_cores": 3.6518466605411906, "engine_peak_rss_mb": 3983.68359375, "measure_secs": 30.001259687, "num_series": 1000000, "sender_cpu_cores": 0.4183157684354869, "target_rate": 415251.2899114012, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 607306.6306883321, "concurrency": 16, "engine_cpu_cores": 4.501802060415265, "engine_peak_rss_mb": 3999.2109375, "measure_secs": 30.001319069, "num_series": 1000000, "sender_cpu_cores": 0.6313055754795286, "target_rate": 622876.9348671018, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 845941.75292754, "concurrency": 16, "engine_cpu_cores": 5.488396896591688, "engine_peak_rss_mb": 3969.19140625, "measure_secs": 30.001474584, "num_series": 1000000, "sender_cpu_cores": 0.8662907527172231, "target_rate": 747452.3218405222, "label": "ddsketch", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 2313963.044391897, "concurrency": 16, "engine_cpu_cores": 7.9994236761730795, "engine_peak_rss_mb": 33.98828125, "measure_secs": 30.00091128, "num_series": 1000000, "sender_cpu_cores": 2.231932202827407, "target_rate": 0.0, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 231189.23125184613, "concurrency": 16, "engine_cpu_cores": 1.7075871275997803, "engine_peak_rss_mb": 32.28125, "measure_secs": 30.001397394, "num_series": 1000000, "sender_cpu_cores": 0.22098970634367643, "target_rate": 231396.30443918973, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 578646.2155541821, "concurrency": 16, "engine_cpu_cores": 3.93386096542077, "engine_peak_rss_mb": 32.8125, "measure_secs": 30.001060291, "num_series": 1000000, "sender_cpu_cores": 0.5659799965501159, "target_rate": 578490.7610979743, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1157007.2758633865, "concurrency": 16, "engine_cpu_cores": 4.764088785986225, "engine_peak_rss_mb": 34.40234375, "measure_secs": 30.001539942, "num_series": 1000000, "sender_cpu_cores": 1.1362750067464522, "target_rate": 1156981.5221959485, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 1735382.7909886907, "concurrency": 16, "engine_cpu_cores": 6.281696388862336, "engine_peak_rss_mb": 33.1484375, "measure_secs": 30.00144998, "num_series": 1000000, "sender_cpu_cores": 1.7392492707780784, "target_rate": 1735472.283293923, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2082858.5533652639, "concurrency": 16, "engine_cpu_cores": 7.544395803493372, "engine_peak_rss_mb": 35.55078125, "measure_secs": 30.001077077, "num_series": 1000000, "sender_cpu_cores": 2.066925792058955, "target_rate": 2082566.7399527074, "label": "cms_heap", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/cms_heap.yaml"} +{"achieved_rate": 2115471.185517008, "concurrency": 16, "engine_cpu_cores": 7.998161378462409, "engine_peak_rss_mb": 397.796875, "measure_secs": 30.000644979, "num_series": 1000000, "sender_cpu_cores": 2.0356229021992056, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 211592.17241559824, "concurrency": 16, "engine_cpu_cores": 1.633939554475839, "engine_peak_rss_mb": 299.90625, "measure_secs": 30.001109812, "num_series": 1000000, "sender_cpu_cores": 0.2053257375677513, "target_rate": 211547.1185517008, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 529038.6710159085, "concurrency": 16, "engine_cpu_cores": 3.760134354668891, "engine_peak_rss_mb": 347.2109375, "measure_secs": 30.001587539, "num_series": 1000000, "sender_cpu_cores": 0.5199724841134181, "target_rate": 528867.796379252, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1058089.458595843, "concurrency": 16, "engine_cpu_cores": 4.689138893499975, "engine_peak_rss_mb": 349.1875, "measure_secs": 30.00124398, "num_series": 1000000, "sender_cpu_cores": 1.039956877148132, "target_rate": 1057735.592758504, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1586630.8051612193, "concurrency": 16, "engine_cpu_cores": 6.263858422392779, "engine_peak_rss_mb": 362.66796875, "measure_secs": 30.000678069, "num_series": 1000000, "sender_cpu_cores": 1.578964311774936, "target_rate": 1586603.389137756, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1903699.4978020424, "concurrency": 16, "engine_cpu_cores": 7.538268698093461, "engine_peak_rss_mb": 382.3984375, "measure_secs": 30.001583793000002, "num_series": 1000000, "sender_cpu_cores": 1.8922334364642988, "target_rate": 1903924.066965307, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/scaling.jsonl b/asap-tools/experiments/microbench/precompute_throughput/results/scaling.jsonl new file mode 100644 index 00000000..7c95e714 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/scaling.jsonl @@ -0,0 +1,10 @@ +{"achieved_rate": 87929.36503712453, "concurrency": 16, "engine_cpu_cores": 0.9999548715366702, "engine_peak_rss_mb": 9997.1875, "measure_secs": 30.001353915, "num_series": 1000000, "sender_cpu_cores": 0.08099634459447029, "target_rate": 0.0, "label": "kll", "workers": 1, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 201570.53225401265, "concurrency": 16, "engine_cpu_cores": 1.7005586697973916, "engine_peak_rss_mb": 10953.75390625, "measure_secs": 30.001905201, "num_series": 1000000, "sender_cpu_cores": 0.18598818850390914, "target_rate": 0.0, "label": "kll", "workers": 2, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 417425.7815861193, "concurrency": 16, "engine_cpu_cores": 3.06561120597903, "engine_peak_rss_mb": 11470.6953125, "measure_secs": 30.000542737, "num_series": 1000000, "sender_cpu_cores": 0.400659418243644, "target_rate": 0.0, "label": "kll", "workers": 4, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 762419.7390335905, "concurrency": 16, "engine_cpu_cores": 5.2835724581040715, "engine_peak_rss_mb": 11399.6171875, "measure_secs": 30.000534914, "num_series": 1000000, "sender_cpu_cores": 0.7849860033332338, "target_rate": 0.0, "label": "kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 970471.9564582388, "concurrency": 16, "engine_cpu_cores": 6.856586286677075, "engine_peak_rss_mb": 11195.80078125, "measure_secs": 30.000351691, "num_series": 1000000, "sender_cpu_cores": 0.9439889335862653, "target_rate": 0.0, "label": "kll", "workers": 14, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 252921.85809158641, "concurrency": 16, "engine_cpu_cores": 0.9999546313584071, "engine_peak_rss_mb": 268.5, "measure_secs": 30.001361121, "num_series": 1000000, "sender_cpu_cores": 0.23165615626469765, "target_rate": 0.0, "label": "hydra_kll", "workers": 1, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 547227.7955755212, "concurrency": 16, "engine_cpu_cores": 1.9922524952976337, "engine_peak_rss_mb": 486.20703125, "measure_secs": 30.001217286, "num_series": 1000000, "sender_cpu_cores": 0.5146457842963938, "target_rate": 0.0, "label": "hydra_kll", "workers": 2, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 974031.594073765, "concurrency": 16, "engine_cpu_cores": 3.699136840116569, "engine_peak_rss_mb": 565.875, "measure_secs": 30.00159356, "num_series": 1000000, "sender_cpu_cores": 0.9776147370753195, "target_rate": 0.0, "label": "hydra_kll", "workers": 4, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 2135904.6589227486, "concurrency": 16, "engine_cpu_cores": 7.999038694875603, "engine_peak_rss_mb": 397.89453125, "measure_secs": 30.001105027, "num_series": 1000000, "sender_cpu_cores": 2.04292475043306, "target_rate": 0.0, "label": "hydra_kll", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} +{"achieved_rate": 1660196.5322728995, "concurrency": 16, "engine_cpu_cores": 9.6492590372567, "engine_peak_rss_mb": 651.4765625, "measure_secs": 30.001267339, "num_series": 1000000, "sender_cpu_cores": 1.5799332562988964, "target_rate": 0.0, "label": "hydra_kll", "workers": 14, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/hydra_kll.yaml"} diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/scaling.out b/asap-tools/experiments/microbench/precompute_throughput/results/scaling.out new file mode 100644 index 00000000..fbde5e31 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/scaling.out @@ -0,0 +1,21 @@ +[kll] series=1000000 workers=1 rate=0 + achieved=87929/s cpu=1.00 cores sender_cpu=0.08 cores rss=9997MB +[kll] series=1000000 workers=2 rate=0 + achieved=201571/s cpu=1.70 cores sender_cpu=0.19 cores rss=10954MB +[kll] series=1000000 workers=4 rate=0 + achieved=417426/s cpu=3.07 cores sender_cpu=0.40 cores rss=11471MB +[kll] series=1000000 workers=8 rate=0 + achieved=762420/s cpu=5.28 cores sender_cpu=0.78 cores rss=11400MB +[kll] series=1000000 workers=14 rate=0 + achieved=970472/s cpu=6.86 cores sender_cpu=0.94 cores rss=11196MB +[hydra_kll] series=1000000 workers=1 rate=0 + achieved=252922/s cpu=1.00 cores sender_cpu=0.23 cores rss=268MB +[hydra_kll] series=1000000 workers=2 rate=0 + achieved=547228/s cpu=1.99 cores sender_cpu=0.51 cores rss=486MB +[hydra_kll] series=1000000 workers=4 rate=0 + achieved=974032/s cpu=3.70 cores sender_cpu=0.98 cores rss=566MB +[hydra_kll] series=1000000 workers=8 rate=0 + achieved=2135905/s cpu=8.00 cores sender_cpu=2.04 cores rss=398MB +[hydra_kll] series=1000000 workers=14 rate=0 + achieved=1660197/s cpu=9.65 cores sender_cpu=1.58 cores rss=651MB +EXIT=0 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/scaling.png b/asap-tools/experiments/microbench/precompute_throughput/results/scaling.png new file mode 100644 index 0000000000000000000000000000000000000000..4026b8b3edc1529aeb637c4eab7f342da1761bcd GIT binary patch literal 23543 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 TSeXtJZpzLbrUp;wj)DIJF4=DF literal 0 HcmV?d00001 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/window.jsonl b/asap-tools/experiments/microbench/precompute_throughput/results/window.jsonl new file mode 100644 index 00000000..34b4fca6 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/window.jsonl @@ -0,0 +1,4 @@ +{"achieved_rate": 693173.5589862084, "concurrency": 16, "engine_cpu_cores": 4.914871609464262, "engine_peak_rss_mb": 1274.0546875, "measure_secs": 30.000783686, "num_series": 100000, "sender_cpu_cores": 0.6919819234484781, "target_rate": 0.0, "label": "kll_tumbling", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/kll.yaml"} +{"achieved_rate": 58624.4632578642, "concurrency": 16, "engine_cpu_cores": 6.98693603040848, "engine_peak_rss_mb": 29719.15234375, "measure_secs": 30.000274668, "num_series": 100000, "sender_cpu_cores": 0.0616661020765025, "target_rate": 0.0, "label": "kll_sliding", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/results/configs/kll_sliding.yaml"} +{"achieved_rate": 598237.6917580235, "concurrency": 16, "engine_cpu_cores": 4.496574153400606, "engine_peak_rss_mb": 454.75390625, "measure_secs": 30.000617225, "num_series": 100000, "sender_cpu_cores": 0.6013209616556481, "target_rate": 0.0, "label": "ddsketch_tumbling", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/configs/ddsketch.yaml"} +{"achieved_rate": 108662.67405954534, "concurrency": 16, "engine_cpu_cores": 5.8527849503421985, "engine_peak_rss_mb": 6150.16015625, "measure_secs": 30.001102294, "num_series": 100000, "sender_cpu_cores": 0.1053294631988231, "target_rate": 0.0, "label": "ddsketch_sliding", "workers": 8, "config": "/scratch/sketch_db_for_prometheus/code/asap-tools/experiments/microbench/precompute_throughput/results/configs/ddsketch_sliding.yaml"} diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/window.out b/asap-tools/experiments/microbench/precompute_throughput/results/window.out new file mode 100644 index 00000000..31e9c764 --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/results/window.out @@ -0,0 +1,9 @@ +[kll_tumbling] series=100000 workers=8 rate=0 + achieved=693174/s cpu=4.91 cores sender_cpu=0.69 cores rss=1274MB +[kll_sliding] series=100000 workers=8 rate=0 + achieved=58624/s cpu=6.99 cores sender_cpu=0.06 cores rss=29719MB +[ddsketch_tumbling] series=100000 workers=8 rate=0 + achieved=598238/s cpu=4.50 cores sender_cpu=0.60 cores rss=455MB +[ddsketch_sliding] series=100000 workers=8 rate=0 + achieved=108663/s cpu=5.85 cores sender_cpu=0.11 cores rss=6150MB +EXIT=0 diff --git a/asap-tools/experiments/microbench/precompute_throughput/results/window.png b/asap-tools/experiments/microbench/precompute_throughput/results/window.png new file mode 100644 index 0000000000000000000000000000000000000000..31bddb909ba9afcbc0a387106b325f403155d5a0 GIT binary patch literal 18169 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 literal 0 HcmV?d00001 diff --git a/asap-tools/experiments/microbench/precompute_throughput/sweep.py b/asap-tools/experiments/microbench/precompute_throughput/sweep.py new file mode 100644 index 00000000..9e22c31f --- /dev/null +++ b/asap-tools/experiments/microbench/precompute_throughput/sweep.py @@ -0,0 +1,270 @@ +"""Precompute-engine throughput microbenchmark sweep. + +Each point starts a fresh `precompute_engine` with N workers pinned to the +first N of --engine-cpus, drives it with `bench_ingest_sender` pinned to +--sender-cpus, and appends the sender's JSON result (plus the point's +parameters) to --out as one line. Give --engine-cpus one hyperthread per +physical core so workers never share a core. + +Build first (in asap-query-engine): + cargo build --release --bin precompute_engine --bin bench_ingest_sender + +Usage: + python sweep.py --bin-dir ../../../../target/release \ + --engine-cpus $(seq -s, 0 2 26) --sender-cpus 1-55:2 \ + --experiment main --out results/main.jsonl + +Experiments: + main every pipeline x cardinality: saturation, then RATE_FRACTIONS of it + fanin KLL with grouping by all labels / l0,l1 / nothing + window KLL and DDSketch, tumbling vs sliding + scaling KLL and HydraKLL at 1M series over WORKER_COUNTS +""" + +import argparse +import json +import os +import socket +import subprocess +import time + +import yaml + +CONFIG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "configs") +PIPELINES = ["kll", "ddsketch", "cms_heap", "hydra_kll"] +# Engine with --pass-raw-samples: decode/route/store cost with no sketching. +RAW_PIPELINE = "raw" +RAW_BASE_CONFIG = "kll" +AGGREGATION_ID = 1 # every config in CONFIG_DIR uses this id + +SERIES_COUNTS = [1_000, 10_000, 100_000, 1_000_000] +DEFAULT_SERIES = 100_000 +# The engine is pinned to as many CPUs as it has workers (taskset), so +# decode/routing on the async runtime can't spill onto extra cores. +DEFAULT_WORKERS = 8 +RATE_FRACTIONS = [0.1, 0.25, 0.5, 0.75, 0.9] +WORKER_COUNTS = [1, 2, 4, 8, 14] +SCALING_SERIES = 1_000_000 +FANIN_GROUPINGS = { + "1to1": ["l0", "l1", "l2", "l3", "l4"], + "100groups": ["l0", "l1"], + "1group": [], +} +SLIDING_WINDOW_MS = 60_000 +SLIDING_SLIDE_MS = 1_000 + +STEP_MS = 1_000 # simulated scrape interval +# The engine handles each request mostly serially, so in-flight requests +# (one per sender) must exceed engine cores or low-cardinality runs measure +# request latency, not throughput. +SENDER_CONCURRENCY = 16 +SAMPLES_PER_REQUEST = 2_000 # Prometheus' default max_samples_per_send +# Must exceed the sender's MAX_PASS_SKEW (2) * STEP_MS, or skewed senders' +# samples are dropped as late. +ALLOWED_LATENESS_MS = 5_000 +# Disables the engine's wall-clock fallback that force-closes panes idle for +# window + grace of wall time. With per-series groups at low rates, one pass +# over all series can exceed that, so it would drop samples the sender still +# counts as acked. The sender always advances event time, so it isn't needed. +WALL_CLOCK_GRACE_PERIOD_MS = 0 +# Store keeps this many x4 windows per key (per_key.rs max_epochs). Memory is +# ~ series x 4 x sketch size, so 1M per-series KLLs stay in tens of GB. +NUM_AGGREGATES_TO_RETAIN = 1 +WARMUP_SECS = 15 +MEASURE_SECS = 30 +BASE_PORT = 19500 +ENGINE_READY_TIMEOUT_SECS = 30 +ENGINE_READY_POLL_SECS = 0.2 +ENGINE_STOP_TIMEOUT_SECS = 10 +SENDER_TIMEOUT_SECS = WARMUP_SECS + MEASURE_SECS + 120 + + +def config_variant(base, out_dir, name, **overrides): + """Write CONFIG_DIR/.yaml with aggregation fields overridden.""" + with open(os.path.join(CONFIG_DIR, f"{base}.yaml")) as f: + cfg = yaml.safe_load(f) + agg = cfg["aggregations"][0] + for key, value in overrides.items(): + if key == "grouping": + agg["labels"]["grouping"] = value + else: + agg[key] = value + path = os.path.join(out_dir, "configs", f"{name}.yaml") + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w") as f: + yaml.safe_dump(cfg, f) + return path + + +def wait_for_port(port, proc): + deadline = time.monotonic() + ENGINE_READY_TIMEOUT_SECS + while time.monotonic() < deadline: + if proc.poll() is not None: + raise RuntimeError(f"engine exited with {proc.returncode} before ready") + with socket.socket() as s: + if s.connect_ex(("127.0.0.1", port)) == 0: + return + time.sleep(ENGINE_READY_POLL_SECS) + raise RuntimeError( + f"engine not listening on {port} after {ENGINE_READY_TIMEOUT_SECS}s" + ) + + +class Runner: + def __init__(self, args): + self.args = args + self.port = BASE_PORT + os.makedirs(os.path.join(args.out_dir, "logs"), exist_ok=True) + + def run(self, label, config_path, series, workers, rate, raw=False): + """One engine + sender run; returns the result dict (also appended to --out).""" + a = self.args + self.port += 1 # fresh port per run sidesteps TIME_WAIT on rebind + engine_cmd = [ + "taskset", "-c", ",".join(a.engine_cpus[:workers]), + os.path.join(a.bin_dir, "precompute_engine"), + "--streaming-config", config_path, + "--num-workers", str(workers), + "--ingest-port", str(self.port), + "--query-port", "0", + "--allowed-lateness-ms", str(ALLOWED_LATENESS_MS), + "--wall-clock-grace-period-ms", str(WALL_CLOCK_GRACE_PERIOD_MS), + "--num-aggregates-to-retain", str(NUM_AGGREGATES_TO_RETAIN), + ] # fmt: skip + if raw: + engine_cmd += [ + "--pass-raw-samples", + "--raw-mode-aggregation-id", + str(AGGREGATION_ID), + ] + log_path = os.path.join( + a.out_dir, "logs", f"{label}_s{series}_w{workers}_r{int(rate)}.log" + ) + print( + f"[{label}] series={series} workers={workers} rate={rate:.0f}", flush=True + ) + with open(log_path, "w") as log: + engine = subprocess.Popen( + engine_cmd, stdout=log, stderr=subprocess.STDOUT, + env={**os.environ, "RUST_LOG": "warn"}, + ) # fmt: skip + try: + wait_for_port(self.port, engine) + sender = subprocess.run( + [ + "taskset", "-c", a.sender_cpus, + os.path.join(a.bin_dir, "bench_ingest_sender"), + "--engine-pid", str(engine.pid), + "--port", str(self.port), + "--num-series", str(series), + "--target-rate", str(rate), + "--concurrency", str(SENDER_CONCURRENCY), + "--samples-per-request", str(SAMPLES_PER_REQUEST), + "--step-ms", str(STEP_MS), + "--warmup-secs", str(WARMUP_SECS), + "--measure-secs", str(MEASURE_SECS), + ], # fmt: skip + capture_output=True, text=True, timeout=SENDER_TIMEOUT_SECS, check=True, + ) # fmt: skip + finally: + engine.terminate() + engine.wait(timeout=ENGINE_STOP_TIMEOUT_SECS) + result = json.loads(sender.stdout.strip().splitlines()[-1]) + result.update(label=label, workers=workers, config=config_path) + with open(a.out, "a") as f: + f.write(json.dumps(result) + "\n") + print( + f" achieved={result['achieved_rate']:.0f}/s " + f"cpu={result['engine_cpu_cores']:.2f} cores " + f"sender_cpu={result['sender_cpu_cores']:.2f} cores " + f"rss={result['engine_peak_rss_mb']:.0f}MB", + flush=True, + ) + return result + + def saturation_then_fractions(self, label, config_path, series, workers, raw=False): + sat = self.run(label, config_path, series, workers, 0, raw) + for frac in RATE_FRACTIONS: + self.run( + label, config_path, series, workers, frac * sat["achieved_rate"], raw + ) + + +def main_experiment(r): + for series in SERIES_COUNTS: + for p in PIPELINES: + r.saturation_then_fractions( + p, os.path.join(CONFIG_DIR, f"{p}.yaml"), series, DEFAULT_WORKERS + ) + raw_cfg = os.path.join(CONFIG_DIR, f"{RAW_BASE_CONFIG}.yaml") + r.saturation_then_fractions( + RAW_PIPELINE, raw_cfg, series, DEFAULT_WORKERS, raw=True + ) + + +def fanin_experiment(r): + for name, grouping in FANIN_GROUPINGS.items(): + cfg = config_variant( + "kll", r.args.out_dir, f"kll_fanin_{name}", grouping=grouping + ) + r.run(f"kll_fanin_{name}", cfg, DEFAULT_SERIES, DEFAULT_WORKERS, 0) + + +def window_experiment(r): + for p in ["kll", "ddsketch"]: + r.run( + f"{p}_tumbling", + os.path.join(CONFIG_DIR, f"{p}.yaml"), + DEFAULT_SERIES, + DEFAULT_WORKERS, + 0, + ) + cfg = config_variant( + p, r.args.out_dir, f"{p}_sliding", + windowType="sliding", windowSizeMs=SLIDING_WINDOW_MS, slideIntervalMs=SLIDING_SLIDE_MS, + ) # fmt: skip + r.run(f"{p}_sliding", cfg, DEFAULT_SERIES, DEFAULT_WORKERS, 0) + + +def scaling_experiment(r): + for p in ["kll", "hydra_kll"]: + for workers in WORKER_COUNTS: + r.run(p, os.path.join(CONFIG_DIR, f"{p}.yaml"), SCALING_SERIES, workers, 0) + + +EXPERIMENTS = { + "main": main_experiment, + "fanin": fanin_experiment, + "window": window_experiment, + "scaling": scaling_experiment, +} + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter + ) + parser.add_argument( + "--bin-dir", + required=True, + help="dir with precompute_engine and bench_ingest_sender", + ) + parser.add_argument( + "--engine-cpus", required=True, type=lambda s: s.split(","), + help="comma list, one CPU per physical core; a run with N workers uses the first N", + ) # fmt: skip + parser.add_argument( + "--sender-cpus", required=True, help="taskset list, disjoint from engine cpus" + ) + parser.add_argument("--experiment", required=True, choices=EXPERIMENTS) + parser.add_argument("--out", required=True, help="results .jsonl (appended)") + args = parser.parse_args() + args.out_dir = os.path.dirname(os.path.abspath(args.out)) + needed = max( + [DEFAULT_WORKERS] + (WORKER_COUNTS if args.experiment == "scaling" else []) + ) + if len(args.engine_cpus) < needed: + parser.error( + f"--engine-cpus has {len(args.engine_cpus)} CPUs; {args.experiment} needs {needed}" + ) + EXPERIMENTS[args.experiment](Runner(args))