From 19fc08cec99c266cc7155a59ca3b1519f4c0b0ae Mon Sep 17 00:00:00 2001 From: Gianni Crivello Date: Mon, 16 Feb 2026 11:35:12 -0500 Subject: [PATCH 01/20] benchmarks for common io --- benchmarks/__init__.py | 0 benchmarks/bench_command_latency.py | 132 ++++++++++++++ benchmarks/bench_file_io.py | 210 +++++++++++++++++++++ benchmarks/bench_network_io.py | 218 ++++++++++++++++++++++ benchmarks/helpers.py | 271 ++++++++++++++++++++++++++++ 5 files changed, 831 insertions(+) create mode 100644 benchmarks/__init__.py create mode 100644 benchmarks/bench_command_latency.py create mode 100644 benchmarks/bench_file_io.py create mode 100644 benchmarks/bench_network_io.py create mode 100644 benchmarks/helpers.py diff --git a/benchmarks/__init__.py b/benchmarks/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/benchmarks/bench_command_latency.py b/benchmarks/bench_command_latency.py new file mode 100644 index 0000000..4a1a90a --- /dev/null +++ b/benchmarks/bench_command_latency.py @@ -0,0 +1,132 @@ +"""Benchmark: per-command SSH round-trip latency. +Measures the overhead of vm.run() vs native subprocess. +""" + +from __future__ import annotations + +import subprocess +import sys + +from helpers import ( + format_stats, + is_sandbox_exec_available, + overhead_str, + print_header, + print_result, + print_subheader, + run_sandboxed, + stats_summary, + time_call_n, +) + +ITERATIONS = 100 +WARMUP = 2 + + +def _host_true() -> None: + subprocess.run(["true"], capture_output=True) + + +def _host_echo() -> None: + result = subprocess.run(["echo", "hello"], capture_output=True, text=True) + assert "hello" in result.stdout + + +def _sandboxed_true() -> None: + run_sandboxed("true") + + +def _sandboxed_echo() -> None: + result = run_sandboxed("echo hello") + assert "hello" in result.stdout + + +def run_benchmark() -> dict: + """Run all command latency benchmarks and return results.""" + from smolvm import SmolVM + + results = {} + + print_header("Command Latency Benchmark") + print(f" Iterations: {ITERATIONS}, Warmup: {WARMUP}") + + # Host baseline + print_subheader("Host: subprocess.run(['true'])") + host_true_times = time_call_n(_host_true, ITERATIONS, warmup=WARMUP) + host_true_stats = stats_summary(host_true_times) + print_result("Stats", format_stats(host_true_stats)) + results["host_true"] = host_true_stats + + print_subheader("Host: subprocess.run(['echo', 'hello'])") + host_echo_times = time_call_n(_host_echo, ITERATIONS, warmup=WARMUP) + host_echo_stats = stats_summary(host_echo_times) + print_result("Stats", format_stats(host_echo_stats)) + results["host_echo"] = host_echo_stats + + # Sandbox baseline + if is_sandbox_exec_available(): + print_subheader("Sandbox: sandbox-exec 'true'") + sandbox_true_times = time_call_n(_sandboxed_true, ITERATIONS, warmup=WARMUP) + sandbox_true_stats = stats_summary(sandbox_true_times) + print_result("Stats", format_stats(sandbox_true_stats)) + results["sandbox_true"] = sandbox_true_stats + + print_subheader("Sandbox: sandbox-exec 'echo hello'") + sandbox_echo_times = time_call_n(_sandboxed_echo, ITERATIONS, warmup=WARMUP) + sandbox_echo_stats = stats_summary(sandbox_echo_times) + print_result("Stats", format_stats(sandbox_echo_stats)) + results["sandbox_echo"] = sandbox_echo_stats + else: + print("\n sandbox-exec not available (non-macOS), skipping sandbox baseline") + results["sandbox_true"] = None + results["sandbox_echo"] = None + + # SmolVM + print_subheader("SmolVM: vm.run('true')") + print(" Starting VM...") + with SmolVM() as vm: + # Sanity check + sanity = vm.run("echo smolvm_sanity") + assert "smolvm_sanity" in sanity.stdout, f"Sanity failed: {sanity.stdout}" + + def _vm_true(): + vm.run("true") + + def _vm_echo(): + result = vm.run("echo hello") + assert "hello" in result.stdout + + vm_true_times = time_call_n(_vm_true, ITERATIONS, warmup=WARMUP) + vm_true_stats = stats_summary(vm_true_times) + print_result("Stats", format_stats(vm_true_stats)) + results["vm_true"] = vm_true_stats + + print_subheader("SmolVM: vm.run('echo hello')") + vm_echo_times = time_call_n(_vm_echo, ITERATIONS, warmup=WARMUP) + vm_echo_stats = stats_summary(vm_echo_times) + print_result("Stats", format_stats(vm_echo_stats)) + results["vm_echo"] = vm_echo_stats + + # domparison + print_subheader("Comparison (p50)") + print_result( + "vm.run('true') vs host", + overhead_str(host_true_stats["p50"], vm_true_stats["p50"]), + ) + print_result( + "vm.run('echo') vs host", + overhead_str(host_echo_stats["p50"], vm_echo_stats["p50"]), + ) + if results.get("sandbox_true"): + print_result( + "vm.run('true') vs sandbox", + overhead_str(results["sandbox_true"]["p50"], vm_true_stats["p50"]), + ) + + return results + + +if __name__ == "__main__": + if "benchmarks" in __file__: + sys.path.insert(0, str(__import__("pathlib").Path(__file__).parent)) + run_benchmark() diff --git a/benchmarks/bench_file_io.py b/benchmarks/bench_file_io.py new file mode 100644 index 0000000..d22ba2a --- /dev/null +++ b/benchmarks/bench_file_io.py @@ -0,0 +1,210 @@ +"""Benchmark: file read/write throughput inside the VM. + +Simulates ralph's JSONL event logging, JSON job files, and session logs. +File IO inside the VM is native ext4 on virtio-blk, but getting results +out requires reading via vm.run("cat ..."). +""" + +from __future__ import annotations + +import os +import sys +import tempfile + +from helpers import ( + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, +) + +# A 1KB line simulating a JSONL event +_1KB_LINE = '{"ts":1234567890,"event":"prompt","session":"abc123","data":' + '"x' * 470 + '"}\n' +assert len(_1KB_LINE) >= 1000 + +_10MB_DATA_LINES = 10240 # ~10MB at 1KB per line + + +def _host_sequential_writes(n: int = 1000) -> float: + """Append n x 1KB lines to a file on the host.""" + + def _do(): + with tempfile.NamedTemporaryFile(mode="w", delete=True, suffix=".jsonl") as f: + for _ in range(n): + f.write(_1KB_LINE) + f.flush() + + return time_call(_do) + + +def _host_bulk_write() -> float: + """Write a single ~10MB file on the host.""" + data = _1KB_LINE * _10MB_DATA_LINES + + def _do(): + with tempfile.NamedTemporaryFile(mode="w", delete=True) as f: + f.write(data) + f.flush() + + return time_call(_do) + + +def _host_bulk_read() -> float: + """Write then read back a ~10MB file on the host.""" + with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".dat") as f: + f.write(_1KB_LINE * _10MB_DATA_LINES) + path = f.name + + def _do(): + with open(path) as f: + _ = f.read() + + t = time_call(_do) + os.unlink(path) + return t + + +def _host_many_small_files(n: int = 100) -> float: + """Create n x 1KB files on the host.""" + + def _do(): + tmpdir = tempfile.mkdtemp() + for i in range(n): + with open(os.path.join(tmpdir, f"job_{i}.json"), "w") as f: + f.write(_1KB_LINE) + # Cleanup + import shutil + + shutil.rmtree(tmpdir) + + return time_call(_do) + + +def run_benchmark() -> dict: + """Run all file IO benchmarks and return results.""" + from smolvm import SmolVM + + results = {} + + print_header("File IO Benchmark") + + # baslines on host + print_subheader("Host: Sequential small writes (1000 x 1KB)") + host_seq_times = [_host_sequential_writes() for _ in range(5)] + host_seq_stats = stats_summary(host_seq_times) + print_result("Stats", format_stats(host_seq_stats)) + results["host_seq_write"] = host_seq_stats + + print_subheader("Host: Bulk write (~10MB)") + host_bulk_w_times = [_host_bulk_write() for _ in range(5)] + host_bulk_w_stats = stats_summary(host_bulk_w_times) + print_result("Stats", format_stats(host_bulk_w_stats)) + results["host_bulk_write"] = host_bulk_w_stats + + print_subheader("Host: Bulk read (~10MB)") + host_bulk_r_times = [_host_bulk_read() for _ in range(5)] + host_bulk_r_stats = stats_summary(host_bulk_r_times) + print_result("Stats", format_stats(host_bulk_r_stats)) + results["host_bulk_read"] = host_bulk_r_stats + + print_subheader("Host: Many small files (100 x 1KB)") + host_many_times = [_host_many_small_files() for _ in range(5)] + host_many_stats = stats_summary(host_many_times) + print_result("Stats", format_stats(host_many_stats)) + results["host_many_files"] = host_many_stats + + # SmolVM + print_subheader("SmolVM: Starting VM...") + with SmolVM() as vm: + # warmup with a sanity check + sanity = vm.run("echo smolvm_ready") + assert "smolvm_ready" in sanity.stdout + + # sequential small writes + print_subheader("SmolVM: Sequential small writes (1000 x 1KB)") + # We write via a single vm.run command using a shell loop + write_cmd = ( + "rm -f /tmp/bench.jsonl; " + "i=0; while [ $i -lt 1000 ]; do " + "printf '%s\\n' '" + _1KB_LINE.strip().replace("'", "'\\''") + "' >> /tmp/bench.jsonl; " + "i=$((i+1)); done" + ) + vm_seq_times = [] + for _ in range(3): + t = time_call(lambda: vm.run(write_cmd, timeout=120)) + vm_seq_times.append(t) + vm_seq_stats = stats_summary(vm_seq_times) + print_result("Stats", format_stats(vm_seq_stats)) + results["vm_seq_write"] = vm_seq_stats + + # Bulk write + print_subheader("SmolVM: Bulk write (~10MB)") + # Use dd to write 10MB of data + bulk_write_cmd = "dd if=/dev/zero of=/tmp/bench_bulk.dat bs=1024 count=10240 2>&1" + vm_bulk_w_times = [] + for _ in range(3): + t = time_call(lambda: vm.run(bulk_write_cmd, timeout=60)) + vm_bulk_w_times.append(t) + vm_bulk_w_stats = stats_summary(vm_bulk_w_times) + print_result("Stats", format_stats(vm_bulk_w_stats)) + results["vm_bulk_write"] = vm_bulk_w_stats + + # Bulk read reading via vm.run("cat ...") + print_subheader("SmolVM: Bulk read (~10MB via cat)") + # First ensure the file exists + vm.run("dd if=/dev/zero of=/tmp/bench_read.dat bs=1024 count=10240 2>/dev/null", timeout=60) + vm_bulk_r_times = [] + for _ in range(3): + t = time_call(lambda: vm.run("cat /tmp/bench_read.dat", timeout=60)) + vm_bulk_r_times.append(t) + vm_bulk_r_stats = stats_summary(vm_bulk_r_times) + print_result("Stats", format_stats(vm_bulk_r_stats)) + results["vm_bulk_read"] = vm_bulk_r_stats + + # Many small files + print_subheader("SmolVM: Many small files (100 x 1KB)") + escaped_line = _1KB_LINE.strip().replace("'", "'\\''") + many_files_cmd = ( + "rm -rf /tmp/bench_jobs; mkdir -p /tmp/bench_jobs; " + "i=0; while [ $i -lt 100 ]; do " + "printf '%s' '" + escaped_line + "'" + " > /tmp/bench_jobs/job_$i.json; " + "i=$((i+1)); done" + ) + vm_many_times = [] + for _ in range(3): + t = time_call(lambda: vm.run(many_files_cmd, timeout=120)) + vm_many_times.append(t) + vm_many_stats = stats_summary(vm_many_times) + print_result("Stats", format_stats(vm_many_stats)) + results["vm_many_files"] = vm_many_stats + + # compare + print_subheader("Comparison (p50)") + print_result( + "Sequential writes: VM vs Host", + overhead_str(host_seq_stats["p50"], vm_seq_stats["p50"]), + ) + print_result( + "Bulk write: VM vs Host", + overhead_str(host_bulk_w_stats["p50"], vm_bulk_w_stats["p50"]), + ) + print_result( + "Bulk read: VM vs Host", + overhead_str(host_bulk_r_stats["p50"], vm_bulk_r_stats["p50"]), + ) + print_result( + "Many files: VM vs Host", + overhead_str(host_many_stats["p50"], vm_many_stats["p50"]), + ) + + return results + + +if __name__ == "__main__": + if "benchmarks" in __file__: + sys.path.insert(0, str(__import__("pathlib").Path(__file__).parent)) + run_benchmark() diff --git a/benchmarks/bench_network_io.py b/benchmarks/bench_network_io.py new file mode 100644 index 0000000..2cac573 --- /dev/null +++ b/benchmarks/bench_network_io.py @@ -0,0 +1,218 @@ +"""Benchmark: network IO between VM and host. + +Measures HTTP round-trip latency and SSE streaming throughput +""" + +from __future__ import annotations + +import http.server +import json +import socket +import subprocess +import sys +import threading +import time + +from helpers import ( + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, + timer, +) + + +def _find_free_port() -> int: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.bind(("", 0)) + return s.getsockname()[1] + + +class _BenchHandler(http.server.BaseHTTPRequestHandler): + """Simple HTTP handler for benchmarking.""" + + def do_GET(self): + if self.path == "/health": + self.send_response(200) + self.send_header("Content-Type", "text/plain") + self.end_headers() + self.wfile.write(b"ok") + elif self.path == "/stream": + self.send_response(200) + self.send_header("Content-Type", "text/event-stream") + self.send_header("Cache-Control", "no-cache") + self.end_headers() + # send SSE events for about 3 seconds + start = time.time() + event_count = 0 + try: + while time.time() - start < 3.0: + data = json.dumps({"event": event_count, "ts": time.time()}) + self.wfile.write(f"data: {data}\n\n".encode()) + self.wfile.flush() + event_count += 1 + time.sleep(0.01) + except (BrokenPipeError, ConnectionResetError): + pass + else: + self.send_response(404) + self.end_headers() + + def log_message(self, format, *args): + pass # Suppress request logging + + +def _start_http_server(port: int) -> http.server.HTTPServer: + """Start a background HTTP server on the given port.""" + server = http.server.HTTPServer(("0.0.0.0", port), _BenchHandler) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + return server + + +def run_benchmark() -> dict: + """Run all network IO benchmarks and return results.""" + from smolvm import SmolVM + + results = {} + + print_header("Network IO Benchmark") + + # Start HTTP server on host + host_port = _find_free_port() + server = _start_http_server(host_port) + print(f" Test HTTP server running on port {host_port}") + + try: + ## here we set up a baseline on tyhe host + print_subheader("Host: HTTP request to localhost") + host_http_times = [] + for _ in range(100): + t = time_call( + lambda: subprocess.run( + ["curl", "-s", f"http://127.0.0.1:{host_port}/health"], + capture_output=True, + timeout=5, + ) + ) + host_http_times.append(t) + host_http_stats = stats_summary(host_http_times) + print_result("Stats (100 iters)", format_stats(host_http_stats)) + results["host_http"] = host_http_stats + + # SSE streaming + print_subheader("Host: SSE streaming (~3s)") + with timer() as t: + result = subprocess.run( + ["curl", "-s", "-N", f"http://127.0.0.1:{host_port}/stream"], + capture_output=True, + text=True, + timeout=10, + ) + host_sse_lines = result.stdout.count("data:") + print_result("Duration", f"{t.elapsed_ms:.0f}ms") + print_result("Events received", str(host_sse_lines)) + results["host_sse_ms"] = t.elapsed_ms + results["host_sse_events"] = host_sse_lines + + # now we bench SmolVM + print_subheader("SmolVM: Starting VM start up") + with SmolVM() as vm: + # warmup with a sanity check + sanity = vm.run("echo smolvm_ready") + assert "smolvm_ready" in sanity.stdout + + curl_check = vm.run("which curl 2>/dev/null || which wget 2>/dev/null || echo 'none'") + has_curl = "curl" in curl_check.stdout + has_wget = "wget" in curl_check.stdout and "none" not in curl_check.stdout + + if not has_curl and not has_wget: + # Install curl in the VM + print(" Installing curl in VM...") + vm.run("apk add --no-cache curl 2>/dev/null || true", timeout=60) + curl_check = vm.run("which curl") + has_curl = "curl" in curl_check.stdout + + # Get the VM's gateway IP + gateway_result = vm.run("ip route | grep default | awk '{print $3}'") + gateway_ip = gateway_result.output.strip() + assert gateway_ip, "Failed to get gateway IP from VM" + print(f" VM gateway IP: {gateway_ip}") + # Port exposure + print_subheader("SmolVM: expose_local() overhead") + # Start a simple server inside the VM for port exposure test + vm.run( + "nohup sh -c 'while true; do " + 'echo -e "HTTP/1.1 200 OK\\r\\nContent-Length: 2\\r\\n\\r\\nok"' + " | nc -l -p 8080 2>/dev/null; done' > /dev/null 2>&1 &" + ) + time.sleep(0.5) + + expose_times = [] + for _ in range(3): + t = time_call(lambda: vm.expose_local(8080)) + expose_times.append(t) + # Clean up for next iteration by unexposing + break # ther is only one meaningful measurement since it caches + expose_stats = stats_summary(expose_times) + print_result("Stats", format_stats(expose_stats)) + results["vm_expose_local"] = expose_stats + + # HTTP requests from VM to host + if has_curl: + fetch_cmd = f"curl -s http://{gateway_ip}:{host_port}/health" + else: + fetch_cmd = f"wget -qO- http://{gateway_ip}:{host_port}/health" + + print_subheader("SmolVM: HTTP request (VM -> host)") + vm_http_times = [] + for _ in range(100): + t = time_call(lambda: vm.run(fetch_cmd, timeout=10)) + vm_http_times.append(t) + vm_http_stats = stats_summary(vm_http_times) + print_result("Stats (100 iters)", format_stats(vm_http_stats)) + results["vm_http"] = vm_http_stats + + # SSE streaming from VM + if has_curl: + print_subheader("SmolVM: SSE streaming (3s, VM -> host)") + with timer() as t: + sse_result = vm.run( + f"curl -s -N --max-time 5 http://{gateway_ip}:{host_port}/stream", + timeout=15, + ) + vm_sse_lines = sse_result.stdout.count("data:") + print_result("Duration", f"{t.elapsed_ms:.0f}ms") + print_result("Events received", str(vm_sse_lines)) + results["vm_sse_ms"] = t.elapsed_ms + results["vm_sse_events"] = vm_sse_lines + else: + print("\n Skipping SSE test (curl not available in VM)") + results["vm_sse_ms"] = None + results["vm_sse_events"] = None + + # compare + print_subheader("Comparison (p50)") + print_result( + "HTTP roundtrip: VM vs Host", + overhead_str(host_http_stats["p50"], vm_http_stats["p50"]), + ) + if results.get("vm_sse_ms") and results.get("host_sse_ms"): + print_result( + "SSE throughput: VM events vs Host events", + f"{results['vm_sse_events']} vs {results['host_sse_events']}", + ) + + finally: + server.shutdown() + + return results + + +if __name__ == "__main__": + if "benchmarks" in __file__: + sys.path.insert(0, str(__import__("pathlib").Path(__file__).parent)) + run_benchmark() diff --git a/benchmarks/helpers.py b/benchmarks/helpers.py new file mode 100644 index 0000000..ff20255 --- /dev/null +++ b/benchmarks/helpers.py @@ -0,0 +1,271 @@ +"""Shared utilities for SmolVM benchmarks. + +Provides timing helpers, statistical functions, sandbox-exec wrappers, +and table formatting for benchmark reporting. +""" + +from __future__ import annotations + +import math +import os +import platform +import shutil +import subprocess +import sys +import tempfile +import time +from collections.abc import Callable +from contextlib import contextmanager +from typing import Any + +# --------------------------------------------------------------------------- +# Timing helpers +# --------------------------------------------------------------------------- + + +@contextmanager +def timer(): + """Context manager that records elapsed wall-clock time in milliseconds. + + Usage:: + + with timer() as t: + do_something() + print(t.elapsed_ms) + """ + t = _TimerResult() + t.start = time.perf_counter() + yield t + t.end = time.perf_counter() + t.elapsed_ms = (t.end - t.start) * 1000.0 + + +class _TimerResult: + start: float = 0.0 + end: float = 0.0 + elapsed_ms: float = 0.0 + + +def time_call(fn: Callable[[], Any]) -> float: + """Run *fn* and return the elapsed time in milliseconds.""" + start = time.perf_counter() + fn() + return (time.perf_counter() - start) * 1000.0 + + +def time_call_n(fn: Callable[[], Any], n: int, *, warmup: int = 0) -> list[float]: + """Run *fn* ``warmup + n`` times and return the last *n* timings in ms.""" + for _ in range(warmup): + fn() + return [time_call(fn) for _ in range(n)] + + +# --------------------------------------------------------------------------- +# Statistics +# --------------------------------------------------------------------------- + + +def percentile(data: list[float], p: float) -> float: + """Return the *p*-th percentile (0-100) of *data*.""" + if not data: + return 0.0 + sorted_data = sorted(data) + k = (p / 100.0) * (len(sorted_data) - 1) + f = math.floor(k) + c = math.ceil(k) + if f == c: + return sorted_data[int(k)] + d0 = sorted_data[f] * (c - k) + d1 = sorted_data[c] * (k - f) + return d0 + d1 + + +def stats_summary(timings: list[float]) -> dict[str, float]: + """Return min, p50, p95, p99, max, mean, and stdev for *timings* (ms).""" + if not timings: + return dict.fromkeys(("min", "p50", "p95", "p99", "max", "mean", "stdev"), 0.0) + n = len(timings) + mean = sum(timings) / n + variance = sum((x - mean) ** 2 for x in timings) / n if n > 1 else 0.0 + return { + "min": min(timings), + "p50": percentile(timings, 50), + "p95": percentile(timings, 95), + "p99": percentile(timings, 99), + "max": max(timings), + "mean": mean, + "stdev": math.sqrt(variance), + } + + +def format_stats(stats: dict[str, float], unit: str = "ms") -> str: + """Format a stats dict as a single readable line.""" + return ( + f"min={stats['min']:.1f}{unit} " + f"p50={stats['p50']:.1f}{unit} " + f"p95={stats['p95']:.1f}{unit} " + f"p99={stats['p99']:.1f}{unit} " + f"max={stats['max']:.1f}{unit} " + f"mean={stats['mean']:.1f}{unit} " + f"stdev={stats['stdev']:.1f}{unit}" + ) + + +# --------------------------------------------------------------------------- +# sandbox-exec wrapper (macOS only) +# --------------------------------------------------------------------------- + +# Minimal Seatbelt profile that allows most operations except network. +# Mirrors the basic approach from nightshift's sandbox.ts. +_SEATBELT_PROFILE = """\ +(version 1) +(allow default) +""" + + +def is_sandbox_exec_available() -> bool: + """Return True if sandbox-exec is available (macOS only).""" + if platform.system() != "Darwin": + return False + return shutil.which("sandbox-exec") is not None + + +def run_sandboxed(command: str, timeout: int = 30) -> subprocess.CompletedProcess[str]: + """Execute *command* via ``sandbox-exec`` with a permissive profile. + + Falls back to plain ``subprocess.run`` if sandbox-exec is unavailable. + """ + if is_sandbox_exec_available(): + # Write a temporary profile + with tempfile.NamedTemporaryFile( + mode="w", suffix=".sb", delete=False + ) as fp: + fp.write(_SEATBELT_PROFILE) + profile_path = fp.name + try: + return subprocess.run( + ["sandbox-exec", "-f", profile_path, "bash", "-c", command], + capture_output=True, + text=True, + timeout=timeout, + ) + finally: + os.unlink(profile_path) + else: + return subprocess.run( + ["bash", "-c", command], + capture_output=True, + text=True, + timeout=timeout, + ) + + +def time_sandboxed(command: str, timeout: int = 30) -> float: + """Run a command via sandbox-exec and return elapsed time in ms.""" + start = time.perf_counter() + run_sandboxed(command, timeout=timeout) + return (time.perf_counter() - start) * 1000.0 + + +def time_host(command: str, timeout: int = 30) -> float: + """Run a command directly on the host and return elapsed time in ms.""" + start = time.perf_counter() + subprocess.run( + ["bash", "-c", command], + capture_output=True, + text=True, + timeout=timeout, + ) + return (time.perf_counter() - start) * 1000.0 + + +# --------------------------------------------------------------------------- +# Table formatting +# --------------------------------------------------------------------------- + + +def format_table( + headers: list[str], + rows: list[list[str]], + *, + align: str | None = None, +) -> str: + """Format a simple ASCII table. + + Args: + headers: Column header strings. + rows: List of rows, each a list of cell strings. + align: Optional alignment string ('l'=left, 'r'=right) per column. + Defaults to left-align for the first column, right for the rest. + """ + if not rows: + return "" + + col_count = len(headers) + if align is None: + align = "l" + "r" * (col_count - 1) + + widths = [len(h) for h in headers] + for row in rows: + for i, cell in enumerate(row): + widths[i] = max(widths[i], len(cell)) + + def _fmt_row(cells: list[str]) -> str: + parts = [] + for i, cell in enumerate(cells): + w = widths[i] + if i < len(align) and align[i] == "r": + parts.append(cell.rjust(w)) + else: + parts.append(cell.ljust(w)) + return "| " + " | ".join(parts) + " |" + + sep = "|" + "|".join("-" * (w + 2) for w in widths) + "|" + lines = [_fmt_row(headers), sep] + lines.extend(_fmt_row(row) for row in rows) + return "\n".join(lines) + + +def overhead_str(base_ms: float, test_ms: float) -> str: + """Return a human-readable overhead string like '2.5x' or '+150ms'.""" + if base_ms <= 0: + return "N/A" + ratio = test_ms / base_ms + diff = test_ms - base_ms + return f"{ratio:.1f}x (+{diff:.0f}ms)" + + +# --------------------------------------------------------------------------- +# Platform info +# --------------------------------------------------------------------------- + + +def platform_info() -> str: + """Return a one-line platform description.""" + system = platform.system() + machine = platform.machine() + version = platform.release() + py_version = sys.version.split()[0] + return f"{system} {machine} (kernel {version}), Python {py_version}" + + +# --------------------------------------------------------------------------- +# Printing helpers +# --------------------------------------------------------------------------- + + +def print_header(title: str) -> None: + """Print a section header.""" + print(f"\n{'=' * 60}") + print(f" {title}") + print(f"{'=' * 60}") + + +def print_subheader(title: str) -> None: + """Print a sub-section header.""" + print(f"\n--- {title} ---") + + +def print_result(label: str, value: str) -> None: + """Print a labelled result.""" + print(f" {label}: {value}") From 9114bf86f79cf493cfd3c27c16f4f77c2e3ad3cf Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Sat, 28 Feb 2026 12:09:09 -0500 Subject: [PATCH 02/20] feat: add density ramp benchmark script and docs Adds a VM density ramp benchmark that boots VMs until failure, measuring boot latency, host resource consumption (CPU, memory, disk, TAP devices, Firecracker RSS), and sustain health checks across all VMs concurrently. Includes README and v0 benchmark/review reports in benchmarks/docs/. Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/density_ramp.py | 393 ++++++++++++++++++ benchmarks/docs/README_DENSITY_RAMP.md | 172 ++++++++ .../docs/v0_density_estimation_benchmark.md | 85 ++++ .../docs/v0_review_density_ramp_report.md | 281 +++++++++++++ 4 files changed, 931 insertions(+) create mode 100644 benchmarks/density_ramp.py create mode 100644 benchmarks/docs/README_DENSITY_RAMP.md create mode 100644 benchmarks/docs/v0_density_estimation_benchmark.md create mode 100644 benchmarks/docs/v0_review_density_ramp_report.md diff --git a/benchmarks/density_ramp.py b/benchmarks/density_ramp.py new file mode 100644 index 0000000..e501be8 --- /dev/null +++ b/benchmarks/density_ramp.py @@ -0,0 +1,393 @@ +#!/usr/bin/env python3 +""" +SmolVM Density Ramp Test + +Ramps VMs until failure, measuring boot latency and host resource consumption. +Tiers: tiny / small / med. Sustain check runs across ALL VMs concurrently after +peak density is reached, not inline per-VM. + +Usage: + pip install smolvm psutil + python density_ramp.py --tier tiny --max-attempts 500 + python density_ramp.py --tier small --shared-disk --parallel 4 +""" + +from __future__ import annotations + +import argparse +import json +import subprocess +import sys +import time +import uuid +from concurrent.futures import ThreadPoolExecutor, as_completed +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any + +import psutil + +try: + from smolvm import SSH_BOOT_ARGS, ImageBuilder, SmolVM, VMConfig + from smolvm.utils import ensure_ssh_key # internal, stable across versions +except ImportError: + print("ERROR: pip install smolvm") + sys.exit(1) + +# Hard ceiling from SmolVM's IP pool (172.16.0.2–172.16.0.254) +SMOLVM_MAX_VMS = 253 + + +# --------------------------------------------------------------------------- +# Metrics +# --------------------------------------------------------------------------- + + +@dataclass +class Metrics: + timestamp: float + vms_running: int + host_cpu_pct: float + host_mem_used_gb: float + host_disk_used_gb: float + tap_count: int = 0 + firecracker_rss_mb: float = 0 + fc_socket_count: int = 0 # live Firecracker sockets in socket_dir + sqlite_db_kb: float = 0 + + @classmethod + def snapshot(cls, vms_running: int, socket_dir: Path) -> "Metrics": + ts = time.time() + cpu = psutil.cpu_percent(interval=0.1) + mem = psutil.virtual_memory().used / (1024**3) + disk = psutil.disk_usage(str(Path.home())).used / (1024**3) + + # Count live Firecracker API sockets (accurate VM count proxy) + fc_sockets = len(list(socket_dir.glob("fc-*.sock"))) + + # TAP device count + try: + ip_out = subprocess.run( + ["ip", "-o", "link", "show"], + capture_output=True, + text=True, + timeout=2, + ).stdout + tap_count = sum(1 for line in ip_out.splitlines() if ": tap" in line) + except Exception: + tap_count = 0 + + # Firecracker aggregate RSS + try: + fc_rss = sum( + p.memory_info().rss / 1024**2 + for p in psutil.process_iter(["name"]) + if "firecracker" in (p.info["name"] or "").lower() + ) + except Exception: + fc_rss = 0.0 + + # SmolVM SQLite state DB size + db_path = Path.home() / ".local" / "state" / "smolvm" / "smolvm.db" + sqlite_kb = db_path.stat().st_size / 1024 if db_path.exists() else 0.0 + + return cls(ts, vms_running, cpu, mem, disk, tap_count, fc_rss, fc_sockets, sqlite_kb) + + +# --------------------------------------------------------------------------- +# VM lifecycle helpers +# --------------------------------------------------------------------------- + +running_vms: list[SmolVM] = [] + + +def cleanup() -> float: + """Stop all running VMs; return elapsed teardown seconds.""" + start = time.time() + for vm in running_vms: + try: + vm.stop() + except Exception: + pass + return time.time() - start + + +def build_image( + tier_config: dict[str, int], + backend: str | None, +) -> tuple[Path, Path, str]: + """Pre-build (or load from cache) the Alpine SSH image. + + Returns (kernel_path, rootfs_path, ssh_key_path). + """ + print("Building/loading image (cached after first run)...") + priv_key, pub_key = ensure_ssh_key() + + disk_size_mib = tier_config["disk_size_mib"] + image_name = "alpine-ssh-key" + if disk_size_mib != 512: + image_name = f"{image_name}-{disk_size_mib}m" + + builder = ImageBuilder() + kernel, rootfs = builder.build_alpine_ssh_key( + pub_key, + name=image_name, + rootfs_size_mb=disk_size_mib, + ) + print(f"Image ready: kernel={kernel.name} rootfs={rootfs.name}") + return kernel, rootfs, str(priv_key) + + +def boot_one( + seq: int, + kernel: Path, + rootfs: Path, + ssh_key_path: str, + tier_config: dict[str, int], + disk_mode: str, + backend: str | None, + socket_dir: Path, +) -> tuple[SmolVM | None, float, dict[str, Any]]: + """Boot a single VM. Returns (vm_or_None, boot_seconds, error_dict).""" + start_t = time.time() + try: + config = VMConfig( + vm_id=f"vm-{uuid.uuid4().hex[:8]}", + vcpu_count=1, + mem_size_mib=tier_config["mem_size_mib"], + kernel_path=kernel, + rootfs_path=rootfs, + boot_args=SSH_BOOT_ARGS, + disk_mode=disk_mode, + backend=backend, + ) + vm = SmolVM(config, ssh_key_path=ssh_key_path, socket_dir=socket_dir) + vm.start() + return vm, time.time() - start_t, {} + except Exception as e: + return None, time.time() - start_t, {"error": str(e)} + + +def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: + """Run a health check on one VM. Returns (seq, alive, error_msg).""" + try: + result = vm.run("uptime", timeout=10) + return seq, result.exit_code == 0, "" + except Exception as e: + return seq, False, str(e) + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="SmolVM Density Ramp") + parser.add_argument("--tier", choices=["tiny", "small", "med"], default="tiny") + parser.add_argument("--max-attempts", type=int, default=500) + parser.add_argument( + "--sustain-sec", + type=int, + default=60, + help="Idle duration (seconds) after peak density before health-checking all VMs", + ) + parser.add_argument( + "--parallel", + type=int, + default=1, + help="Number of VMs to boot concurrently per batch", + ) + parser.add_argument( + "--shared-disk", + action="store_true", + help="Use disk_mode=shared (no per-VM rootfs clone); saves disk, less isolation", + ) + parser.add_argument( + "--backend", + default=None, + help="Backend override: firecracker, qemu, or auto", + ) + parser.add_argument( + "--socket-dir", + type=Path, + default=Path("/tmp"), + help="Firecracker socket directory (must match SmolVM runtime default)", + ) + parser.add_argument("--output", default="density.json") + args = parser.parse_args() + + tiers = { + "tiny": dict(mem_size_mib=128, disk_size_mib=512), + "small": dict(mem_size_mib=512, disk_size_mib=1024), + "med": dict(mem_size_mib=2048, disk_size_mib=4096), + } + tier_config = tiers[args.tier] + disk_mode = "shared" if args.shared_disk else "isolated" + + # Guard: SmolVM IP pool hard ceiling + if args.max_attempts > SMOLVM_MAX_VMS: + print( + f"WARNING: SmolVM IP pool caps at {SMOLVM_MAX_VMS} VMs. " + f"Clamping --max-attempts from {args.max_attempts} to {SMOLVM_MAX_VMS}." + ) + args.max_attempts = SMOLVM_MAX_VMS + + # Warn about disk usage in isolated mode + if disk_mode == "isolated": + est_disk_gb = (args.max_attempts * tier_config["disk_size_mib"]) / 1024 + free_gb = psutil.disk_usage(str(Path.home())).free / (1024**3) + print( + f"INFO: isolated mode — up to {est_disk_gb:.0f} GB disk needed; " + f"{free_gb:.1f} GB free on home filesystem." + ) + if est_disk_gb > free_gb * 0.8: + print( + "WARNING: Risk of disk exhaustion before memory. " + "Consider --shared-disk to eliminate per-VM clones." + ) + + kernel, rootfs, ssh_key_path = build_image(tier_config, args.backend) + + results: list[dict[str, Any]] = [] + + try: + i = 0 + while i < args.max_attempts: + batch_size = min(args.parallel, args.max_attempts - i) + + # Boot one batch (serial or parallel) + if batch_size == 1: + batch_results = [ + boot_one( + i + 1, + kernel, + rootfs, + ssh_key_path, + tier_config, + disk_mode, + args.backend, + args.socket_dir, + ) + ] + else: + with ThreadPoolExecutor(max_workers=batch_size) as ex: + futures = [ + ex.submit( + boot_one, + i + j + 1, + kernel, + rootfs, + ssh_key_path, + tier_config, + disk_mode, + args.backend, + args.socket_dir, + ) + for j in range(batch_size) + ] + batch_results = [f.result() for f in as_completed(futures)] + + failed_this_batch = 0 + for vm, boot_t, err in batch_results: + i += 1 + density = len(running_vms) + (1 if vm is not None else 0) + snap = Metrics.snapshot(density, args.socket_dir) + + if vm is not None: + running_vms.append(vm) + print( + f"VM {i}: boot={boot_t:.2f}s | " + f"mem={snap.host_mem_used_gb:.2f}GB " + f"disk={snap.host_disk_used_gb:.2f}GB " + f"tap={snap.tap_count} " + f"fc_rss={snap.firecracker_rss_mb:.0f}MB" + ) + results.append( + { + "event": "boot_ok", + "vm_seq": i, + "boot_time_s": round(boot_t, 3), + "density_at_boot": len(running_vms), + **asdict(snap), + } + ) + else: + print(f"FAIL @ VM {i}: {err.get('error', '?')}") + results.append( + { + "event": "boot_fail", + "vm_seq": i, + **err, + **asdict(snap), + } + ) + failed_this_batch += 1 + + if failed_this_batch == batch_size: + print("Entire batch failed — stopping ramp.") + break + + peak = len(running_vms) + print(f"\nPeak density: {peak} VMs (tier={args.tier}, disk_mode={disk_mode})") + + # ------------------------------------------------------------------ + # Sustain phase: idle all VMs together, then health-check concurrently + # ------------------------------------------------------------------ + if peak > 0 and args.sustain_sec > 0: + print(f"Sustaining {peak} VMs for {args.sustain_sec}s...") + time.sleep(args.sustain_sec) + + print(f"Running concurrent health checks across all {peak} VMs...") + workers = min(peak, 64) + with ThreadPoolExecutor(max_workers=workers) as ex: + futures = { + ex.submit(check_vm_alive, vm, idx + 1): idx + for idx, vm in enumerate(running_vms) + } + alive_count = 0 + dead_vms: list[int] = [] + for future in as_completed(futures): + seq, alive, err_msg = future.result() + if alive: + alive_count += 1 + else: + dead_vms.append(seq) + if err_msg: + print(f" VM {seq} dead: {err_msg}") + + snap = Metrics.snapshot(peak, args.socket_dir) + print( + f"Sustain result: {alive_count}/{peak} VMs alive " + f"({len(dead_vms)} dead: {dead_vms[:10]}{'...' if len(dead_vms) > 10 else ''})" + ) + results.append( + { + "event": "sustain_check", + "sustain_sec": args.sustain_sec, + "vms_alive": alive_count, + "vms_dead": dead_vms, + "vms_checked": peak, + **asdict(snap), + } + ) + + finally: + print("Tearing down VMs...") + teardown_s = cleanup() + snap = Metrics.snapshot(0, args.socket_dir) + print( + f"Teardown: {teardown_s:.1f}s | " + f"disk after cleanup={snap.host_disk_used_gb:.2f}GB " + f"(delta verifies rootfs clones released)" + ) + results.append( + { + "event": "teardown", + "teardown_time_s": round(teardown_s, 2), + **asdict(snap), + } + ) + + with open(args.output, "w") as f: + json.dump(results, f, indent=2) + print(f"Results written to {args.output}") diff --git a/benchmarks/docs/README_DENSITY_RAMP.md b/benchmarks/docs/README_DENSITY_RAMP.md new file mode 100644 index 0000000..e31537d --- /dev/null +++ b/benchmarks/docs/README_DENSITY_RAMP.md @@ -0,0 +1,172 @@ +# Density Ramp Benchmark + +## Overview + +`density_ramp.py` is a stress test that measures SmolVM's maximum capacity by progressively creating and booting VMs until system resource exhaustion. It collects detailed metrics on host performance and individual VM boot times to characterize the limits of the Firecracker-based runtime. + +## Purpose + +This benchmark helps answer key questions about SmolVM: +- **Maximum concurrent VMs**: How many VMs can run simultaneously on a given system? +- **Performance degradation**: How do boot times and system metrics change as density increases? +- **Resource utilization**: What are the per-VM resource costs (CPU, memory)? +- **Failure modes**: What resource limits cause deployments to fail? + +## Usage + +### Basic Invocation + +```bash +python density_ramp.py --tier tiny --max_attempts 500 +``` + +### Arguments + +| Argument | Type | Default | Description | +|----------|------|---------|-------------| +| `--tier` | `{tiny, small, med}` | `tiny` | VM size configuration tier | +| `--max_attempts` | int | `500` | Maximum number of VMs to launch | +| `--sustain_sec` | int | `60` | Idle duration (seconds) to wait between VM boots for stability check | +| `--output` | string | `density.json` | Output file path for results (JSON format) | + +### VM Tiers + +Each tier defines VM memory and disk size: + +| Tier | Memory | Disk | +|------|--------|------| +| `tiny` | 128 MiB | 512 MiB | +| `small` | 512 MiB | 1 GiB | +| `med` | 2048 MiB | 4 GiB | + +## How It Works + +1. **Boot Loop**: For each iteration (up to `--max_attempts`): + - Create a new VM with the specified tier configuration + - Boot it and record boot time + - Keep it running (append to active VM list) + - Wait `--sustain_sec` seconds + - Run a quick liveness check (`sleep 1 && uptime`) + - Capture host metrics (CPU, memory, Firecracker RSS, KVM VM count) + +2. **Failure Handling**: If any VM fails to boot or fails the liveness check, the test stops and records the failure point. + +3. **Metrics Collection**: For each successful VM, the benchmark captures: + - Boot time (seconds) + - Timestamp + - Number of VMs running + - Host CPU utilization (%) + - Host memory used (GB) + - Active KVM VM count + - Total Firecracker RSS memory (MB) + +4. **Cleanup**: On exit (success, failure, or interrupt), all VMs are stopped gracefully. + +## Output Format + +Results are written to a JSON file (default: `density.json`): + +```json +[ + { + "vm_id": 1, + "boot_time_s": 0.45, + "timestamp": 1699564800.123, + "vms_running": 1, + "host_cpu_pct": 12.5, + "host_mem_used_gb": 2.3, + "kvm_vms": 1, + "firecracker_rss_mb": 156.2 + }, + ... + { + "failure_at": 245, + "error": "Out of memory", + "timestamp": 1699564900.456, + "vms_running": 244, + "host_cpu_pct": 85.0, + "host_mem_used_gb": 15.8, + "kvm_vms": 244, + "firecracker_rss_mb": 15200.0 + } +] +``` + +## Prerequisites + +- Linux system with KVM support +- SmolVM installed: `pip install smolvm psutil` +- Sufficient disk space for the rootfs/kernel images +- Firecracker binary available on the system + +## Example Runs + +### Tiny VMs (Max Capacity Test) +```bash +python density_ramp.py --tier tiny --max_attempts 1000 --sustain_sec 30 --output tiny_density.json +``` +Good for finding absolute maximum concurrent VM count with minimal overhead. + +### Small VMs (Realistic Mixed Workload) +```bash +python density_ramp.py --tier small --max_attempts 100 --sustain_sec 60 --output small_density.json +``` +Realistic for typical application workloads. + +### Medium VMs (Headroom Test) +```bash +python density_ramp.py --tier med --max_attempts 50 --sustain_sec 60 --output med_density.json +``` +Tests system behavior under heavier individual VM loads. + +## Analysis & Interpretation + +After running the benchmark: + +1. **Look at the final record** to identify the failure point and surrounding metrics +2. **Bootstrap time trend**: Is boot time degrading as VMs accumulate? +3. **Memory usage**: How does host memory consumption scale with VM count? +4. **Firecracker RSS**: Individual Firecracker process overhead +5. **CPU contention**: Does CPU utilization increase as density rises? + +Example analysis (Python): +```python +import json + +with open('density.json') as f: + data = json.load(f) + +# Find where it failed +if 'failure_at' in data[-1]: + print(f"Max VMs: {data[-1]['failure_at']}") +else: + print(f"Max VMs: {len(data)}") + +# Boot time trend +boot_times = [d.get('boot_time_s') for d in data if 'boot_time_s' in d] +print(f"Avg boot: {sum(boot_times) / len(boot_times):.2f}s") +print(f"Max boot: {max(boot_times):.2f}s") +``` + +## Notes + +- This is a "first draft" benchmark and is maintained in "skepticism mode", meaning results should be interpreted carefully and may vary significantly based on host system configuration +- The liveness check (`sleep 1 && uptime`) ensures VMs remain responsive, not just that they booted +- Firecracker RSS includes all Firecracker processes, not per-VM attribution +- The test does not perform VM cleanup between iterations—all VMs remain running until the end +- On macOS, this test will not run (KVM is Linux-only); use a Linux system for density testing + +## Troubleshooting + +| Issue | Cause | Solution | +|-------|-------|----------| +| "ERROR: pip install smolvm" | SmolVM not installed | `pip install smolvm psutil` | +| Quick failure (VM 1 or 2) | Missing Firecracker binary | Run `smolvm demo list` to trigger setup | +| High failure rate | Insufficient disk space | Free up space or use smaller tier | +| Inconsistent results | System load variation | Run test with minimal background processes | +| KVM device errors | Permissions issue | Check KVM device permissions (`/dev/kvm`) | + +## See Also + +- [SmolVM Documentation](../README.md) +- [Other Benchmarks](../) diff --git a/benchmarks/docs/v0_density_estimation_benchmark.md b/benchmarks/docs/v0_density_estimation_benchmark.md new file mode 100644 index 0000000..a286182 --- /dev/null +++ b/benchmarks/docs/v0_density_estimation_benchmark.md @@ -0,0 +1,85 @@ +SmolVM Benchmarking Plan 🧪 + +Repo cloned (workspace/SmolVM-benchmarks). + +Existing benches: command latency, file I/O (ralph JSONL sim), net I/O. + +No density script—custom needed. + +SmolVM: Firecracker/KVM backend, ~572ms boot, low overhead. Firecracker hits 1000s/host in Lambda-scale, but per-instance varies (e.g., OCI BM > VM nested). + +1. Density (Max VMs) +Local Test First (your host equiv Ryzen 7): +```from smolvm import SmolVM +vms = [] +i = 0 +while True: + try: + vm = SmolVM(mem_size_mib=128, disk_size_mib=512) # Minimal + vm.start() + vms.append(vm) + i += 1 + print(f"VM {i} OK") + except Exception as e: + print(f"Max: {i}, Fail: {e}") + break +``` +Ramp until OOM/KVM slots (~host vCPUs). + +Metrics: ps -o rss,vsz %cpu per PID, /sys/kernel/debug/kvm slots. + + +| Instance | vCPU | Mem (GiB) | Est Max VMs | +|----------|------|----------|------------| +| t4g.nano | 2 | 0.5 | ~10-20 | +| t3.micro | 2 | 1 | ~20-50 | +| m5.large | 2 | 8 | ~100-200 | +| c5.xlarge | 4 | 8 | ~150-300 | + +Automate: Boto3 launch, SSM run test, CloudWatch mem/CPU. + +GCE: Similar (e2-micro/standard-2/4), gcloud compute. + + +Skepticism Mode Review: SmolVM Benchmarking Plan 🧐 + +(Embodying Skepticism Mode: Questioning assumptions, probing unverified claims, prioritizing precision/evidence over optimism. "So What?" test: Does this measure real value for AI agent workloads? Sources: memory/project-smolvm.md; repo benches; Firecracker docs.) + +1. Core Assumptions Flagged (Unproven/Fragile) + - Minimal Config Realism: 128MB mem/512MB disk "minimal" VMs—fine for boot tests, but ignores real workloads. AI agents run LLMs/tools: Need 1-4GB+ for pip install torch, API calls, or even curl. Assumption: Toy VMs proxy production? No—measure tiered: tiny (idle), small (Python script), med (LLM inference). + + - Firecracker Equivalence: SmolVM wraps Firecracker. Density = SmolVM overhead + Firecracker base. Plan doesn't isolate: What's raw Firecracker max? (Lambda claims ~4k/node, but EC2 varies 100-1k/instance per blogs/arXiv.) + + - Cloud Nested Virt Penalty: EC2/GCE VMs = nested KVM. Firecracker docs warn 20-50% perf hit vs bare-metal. t3.micro (lite) lacks dedicated KVM accel. Verify baseline on metal/EC2 bare-metal (i3.metal). + + - OOM/KVM as Sole Limiters: Ignores host limits: /proc/sys/kernel/threads-max, netif (TAP FD exhaustion >500 VMs), IRQ saturation, cgroup v2 memsw. + +1. Missing Metrics (What You're Not Measuring—Critical Gaps) + + +| Category | Plan Has | Missing (Why Matters) | Suggested Add | +|----------|----------|----------------------|---------------| +| Density | Max concurrent boot | Sustained uptime/crash rate (e.g., 1hr idle/active); Ramp-up time (boot 100 VMs serially? Parallel?); Teardown speed (leakage?); Per-VM breakdown (firecracker PID RSS/VSZ/CPU; guest mem via free; KVM slots via ls /dev/kvm-vm*; cat /sys/kernel/debug/kvm/max_vms). | htop --filter=firecracker; kvm stats; aggregate psutil script. | +| Performance | Boot/cmd/file/net I/O | CPU-bound (sysbench/prime95 guest); Multi-VM contention (contention @50%/90% density); Tail latency (p99 cmd exec @100 VMs); Power/$$ (cloud: CPU credits/cost/hour at density); Net saturation (iperf3 multi-stream @ density). | fio (rand/seq RW); stress-ng CPU; perf top (host KVM irq). | +| I/O Depth | File (JSONL sim) | Block device (virtio vs NVMe passthru); Multi-VM I/O storm (all VMs randwrite sim); Host cache effects (fio --direct=1); Guest fs (ext4 vs tmpfs). | fio --name=randrw --bs=4k --iodepth=32; blktrace host. | +| Comparisons | Vs Firecracker/KVM | Raw baselines (no SmolVM wrapper); Containers (Docker/podman for context); gVisor (kernel sim). | Fork Firecracker repo; docker stats. | +| Stability/Safety | N/A | Attack surface (escape tests?); Resource leaks (post-kill mem?); Host impact (temp rise, net flood). | falco/auditd guest-host; valgrind firecracker? | + + +1. Risks/Edge Cases Overlooked + - Fork Drift: tensor-ninja vs CelestoAI—bench both? Latest commits? + - Host Tuning: No /etc/sysctl (e.g., net.core.somaxconn, vm.swappiness=0)? Firecracker needs modprobe vhost_vsock. + - Reproducibility: Single-run? No stats (mean/std/p95)? No CI (GitHub Actions matrix)? + - Scale Reality: 300 VMs/c5.xlarge optimistic—Lambda tunes kernel specially. EC2 spot kills mid-test. + - "So What?" Fail: Max density cool, but throughput/$$ per VM matters more for agents (e.g., VMs/hour * success rate). + +1. Revised Plan Skeleton (Precision Fixes) +Phases: + 1. Local Baseline: Tune host → Run repo benches → Density ramp (3 tiers) → Stats table. + 2. Raw Firecracker: Build/run equivalent VMs. + 3. Cloud: Bare-metal → Nested → Automate (terraform + boto3/gcloud). + +- Output: CSV (inst|density|max_mem|boot_p95|io_mb/s|cost/hr) + graphs. +- Cost Guardrail: t3.micro spot ~$0.002/hr; cap 10 instances. + +- Verdict: Plan 6/10—good start (local/EC2 targets), but toy-focused, no contention/realism, weak baselines. Fix gaps → actionable. \ No newline at end of file diff --git a/benchmarks/docs/v0_review_density_ramp_report.md b/benchmarks/docs/v0_review_density_ramp_report.md new file mode 100644 index 0000000..1326a4d --- /dev/null +++ b/benchmarks/docs/v0_review_density_ramp_report.md @@ -0,0 +1,281 @@ +# SmolVM Density Ramp — Test Harness Report + +## Overview + +`density_ramp.py` is a stress test that answers one core question: **how many SmolVM +microVMs can a given host run simultaneously before something breaks?** It ramps up VMs +one-by-one (or in parallel batches), captures host resource state at each step, sustains +the peak density for a configurable idle window, then tears down cleanly and verifies +resource release. + +--- + +## What It Tests + +### 1. Boot Density Ramp + +The test progressively launches microVMs with a fixed configuration tier until one of +three terminal conditions is reached: + +- **An entire boot batch fails** — the host can no longer start new VMs. +- **`--max-attempts` is reached** — the configured ceiling (capped at 253, the hard + limit of SmolVM's IP pool) is hit before failure. +- **The user interrupts** — `finally` ensures cleanup regardless. + +Each boot is timed from `SmolVM(config).start()` call to return. The sequence number at +which each VM was booted (`density_at_boot`) is recorded alongside the boot time, so a +plot of `boot_time_s` vs `density_at_boot` shows whether boot latency degrades under +load. + +The three tiers define the per-VM footprint: + +| Tier | Guest RAM | Rootfs Size | Realistic use case | +|-------|-----------|-------------|----------------------------------| +| tiny | 128 MiB | 512 MiB | Idle sandbox, trivial scripts | +| small | 512 MiB | 1 GiB | Python tooling, pip installs | +| med | 2 GiB | 4 GiB | Light inference, larger installs | + +### 2. Sustain Phase + +After the ramp exhausts, the full set of running VMs is held for `--sustain-sec` +(default 60 s). Then `vm.run("uptime", timeout=10)` is dispatched concurrently across +all VMs (up to 64 threads). A VM is alive if and only if `exit_code == 0` is returned +within the timeout. Silently crashed or OOM-killed VMs will surface here. + +### 3. Teardown and Resource Release + +`cleanup()` calls `vm.stop()` on every running VM. The post-cleanup `Metrics.snapshot()` +is written to the output, so the disk usage delta (pre- vs post-cleanup) can be compared +against the expected per-VM clone size. A mismatch indicates leaked rootfs clones. + +--- + +## Metrics Collected + +At every boot event and at the sustain/teardown checkpoints, the following are recorded: + +| Field | Source | What it tells you | +|----------------------|---------------------------------------|------------------------------------------------------------------------| +| `boot_time_s` | Wall clock around `vm.start()` | Per-VM boot latency; should be flat; degradation indicates I/O or scheduler saturation | +| `density_at_boot` | `len(running_vms)` at success | X-axis for the boot latency curve | +| `host_mem_used_gb` | `psutil.virtual_memory().used` | Actual host RAM consumed; slope = overhead per VM | +| `host_disk_used_gb` | `psutil.disk_usage(home).used` | Tracks rootfs clone growth in isolated mode; should recover after teardown | +| `host_cpu_pct` | `psutil.cpu_percent(interval=0.1)` | Transient boot-time CPU; sustained high values indicate host saturation | +| `tap_count` | `ip -o link show \| grep tap` | Each Firecracker VM owns one TAP device; should equal `vms_running` | +| `fc_socket_count` | `glob("/tmp/fc-*.sock")` | Number of live Firecracker API sockets; cross-checks `vms_running` | +| `firecracker_rss_mb` | Sum of RSS for all `firecracker` PIDs | Hypervisor overhead per VM independent of guest memory allocation | +| `sqlite_db_kb` | `stat(~/.local/state/smolvm/smolvm.db)` | State DB grows with each VM record; large size risks lock contention | + +The output JSON groups events by type: `boot_ok`, `boot_fail`, `sustain_check`, +`teardown`. + +--- + +## Why These Tests Are Relevant + +SmolVM's target workload is **on-demand AI agent sandboxes**: an agent task arrives, +a fresh microVM boots, the task executes, the VM is discarded. The density ramp +directly exercises the two properties that determine whether this model is economical +at scale. + +### Capacity per dollar + +The primary output — peak VM count — directly determines cost efficiency. If a +`c5.2xlarge` ($0.34/hr) sustains 60 simultaneous tiny-tier VMs, and each agent task +takes 2 minutes on average, the instance can process 1,800 tasks/hr at ~$0.0002/task. +Without the density number, any cost estimate is guesswork. + +### What the metrics reveal about SmolVM's architecture + +**`host_mem_used_gb` slope** measures true per-VM overhead. The naive expectation is +`128 MiB (guest) + ~20 MiB (Firecracker process)` = ~150 MiB per tiny-tier VM, yielding +~50 VMs on 8 GiB. If the measured slope is steeper — say 200 MiB/VM — it indicates +additional overhead from TAP buffers, kernel per-process structures, or smolvm state. +This is actionable: it means the guest memory setting is not the binding constraint and +simply reducing `mem_size_mib` further will not improve density as much as expected. + +**`boot_time_s` vs `density_at_boot` curve** reveals I/O and scheduler behaviour. +Firecracker VMs boot by cloning a rootfs image (in isolated mode) and writing it to +disk. If boot time at VM #80 is 3× that at VM #1, the host NVMe or the kernel's +per-process file copy is saturating — even though there is still free RAM. This matters +for burst workloads: a sharp latency cliff means you cannot spin up 50 VMs quickly, +only sequentially. + +**`tap_count` and `fc_socket_count`** cross-check `vms_running`. If `fc_socket_count < +vms_running`, Firecracker processes have exited silently — the VM count reported by +SmolVM is stale. This would be a serious reliability bug. Conversely, if `tap_count > +vms_running` after teardown, TAP devices are leaking and will accumulate across test +runs until a reboot or manual cleanup. + +**`host_disk_used_gb` delta at teardown** validates that `disk_mode=isolated` cleans up +properly. In isolated mode SmolVM clones the rootfs image per VM to +`~/.local/state/smolvm/disks/{vm_id}.ext4`. The post-teardown disk reading should +return to approximately the pre-test baseline. A persistent increase indicates leaked +clone files, which will silently exhaust disk on long-running hosts. + +**`sustain_check` alive ratio** distinguishes between VMs that boot successfully but +later crash (OOM-killed by the host kernel, or KVM slot exhausted) versus VMs that were +never viable. A 100% boot success rate followed by a 70% sustain rate is a qualitatively +different failure mode than a ramp that stops at 70%. + +**`sqlite_db_kb`** is a canary for state management overhead. SmolVM tracks all VM +state in a single SQLite file with exclusive transactions. In serial operation this is +fine; under `--parallel` load the DB is accessed from multiple threads simultaneously. +A DB size that grows without bound (i.e., records are not cleaned up on stop/delete) +would eventually degrade all write operations. + +--- + +## How to Administer the Tests + +### Prerequisites + +- Linux host with KVM enabled: `ls /dev/kvm` must succeed. +- Running as a user with permission to create TAP devices and iptables rules, or as root. +- `pip install smolvm psutil` +- Enough disk for the chosen tier (see the pre-run warning printed by the script). + +### Recommended test sequence + +**Step 1 — Baseline, serial, shared-disk** + +Establishes the memory-bound ceiling without disk being a confounding variable. + +```bash +python density_ramp.py \ + --tier tiny \ + --shared-disk \ + --sustain-sec 60 \ + --output results_tiny_shared.json +``` + +**Step 2 — Isolated mode to measure disk behaviour** + +Run the same tier with `--max-attempts` set conservatively (e.g. 50) to avoid filling +the disk, then inspect the teardown delta. + +```bash +python density_ramp.py \ + --tier tiny \ + --max-attempts 50 \ + --sustain-sec 60 \ + --output results_tiny_isolated.json +``` + +**Step 3 — Parallel boot to stress concurrent allocation** + +This exercises the TAP device setup, iptables rule insertion, and SQLite state writes +under concurrency. Use a moderate parallelism — start at 4, not 32. + +```bash +python density_ramp.py \ + --tier tiny \ + --shared-disk \ + --parallel 4 \ + --sustain-sec 30 \ + --output results_tiny_parallel4.json +``` + +**Step 4 — Realistic tier** + +Repeat steps 1–3 with `--tier small` to model real agent workloads (Python installs, +API calls). The tiny tier is primarily useful for measuring hypervisor overhead in +isolation. + +### Reading the output + +The JSON output is a flat array of event records. Quick analysis: + +```python +import json, statistics + +records = json.load(open("results_tiny_shared.json")) +boots = [r for r in records if r["event"] == "boot_ok"] + +print("Peak density:", max(r["density_at_boot"] for r in boots)) +print("Boot time p50:", statistics.median(r["boot_time_s"] for r in boots)) +print("Boot time p95:", statistics.quantiles([r["boot_time_s"] for r in boots], n=20)[18]) + +mem_per_vm = (boots[-1]["host_mem_used_gb"] - boots[0]["host_mem_used_gb"]) / len(boots) +print(f"Measured mem overhead per VM: {mem_per_vm*1024:.0f} MiB") + +sustain = next(r for r in records if r["event"] == "sustain_check") +print(f"Sustain: {sustain['vms_alive']}/{sustain['vms_checked']} alive") + +teardown = next(r for r in records if r["event"] == "teardown") +print(f"Teardown time: {teardown['teardown_time_s']}s") +``` + +--- + +## Pitfalls and Things to Watch For + +### Disk exhaustion will abort the test before memory is exhausted + +In `isolated` mode (the default), SmolVM clones the rootfs image for every VM. A +standard cloud instance root volume of 8 GiB is exhausted by ~16 tiny-tier VMs or ~8 +small-tier VMs. The script prints a warning and estimated disk requirement before +starting. Use `--shared-disk` when you want to measure memory-bound density, not +disk-bound density. Use isolated mode when you want to validate that the cleanup path +actually releases clones. + +### The 253-VM ceiling is architectural, not a performance limit + +SmolVM allocates guest IPs from a fixed `/24` subnet (`172.16.0.2–172.16.0.254`), TAP +devices named `tap2–tap254`, and SSH host ports from `2200–2999`. The script clamps +`--max-attempts` to 253. Hitting this ceiling before running out of RAM is a valid and +informative result — it means the host could support more VMs if the networking layer +were extended, not that the hardware is exhausted. + +### Nested KVM on cloud instances inflates all timings + +EC2, GCE, and Azure VM instances run Firecracker under a second layer of KVM +virtualisation. This imposes a 20–50% overhead on boot times and CPU-bound operations +compared to bare metal. Results from nested environments are internally consistent and +useful for relative comparisons (tier vs tier, isolated vs shared) but should not be +treated as representative of what SmolVM can do on a bare-metal host. For absolute +density numbers, use a bare-metal instance or a local machine with direct KVM access. + +### ARM instances require matching kernel and rootfs images + +`t4g` (Graviton) and other ARM instances use `aarch64`. The Alpine SSH image +pre-built by `ImageBuilder` is compiled for the host architecture. If you copy results +files between x86 and ARM hosts, the images are not interchangeable. The script will +fail at image build time with a meaningful error if there is a mismatch, but be aware +that `--tier` timings are not comparable across architectures. + +### `--parallel` with high concurrency exposes SQLite contention + +SmolVM serialises all VM state writes through a single SQLite database with exclusive +transactions. With `--parallel 1` this is invisible. At `--parallel 8` or higher, boot +threads queue behind the DB lock and measured boot times will include wait time that is +not present in production single-VM usage. Watch `sqlite_db_kb` growing suspiciously +large or boot times clustering around a suspiciously regular interval as signs of +contention. If you see this, the finding is real and worth reporting: it means concurrent +agent spawning is slower than sequential spawning even when RAM is not the constraint. + +### Leaked resources from interrupted runs + +If the script is killed with `SIGKILL` (e.g. `kill -9`, OOM killer), the `finally` +block does not run. Firecracker processes continue running, TAP devices remain, and +rootfs clone files remain on disk. Before re-running after an interrupted test: + +```bash +smolvm cleanup --all # stops all tracked VMs and removes their state +ip link show | grep tap # verify no stale TAP devices +ls /tmp/fc-*.sock # verify no stale Firecracker sockets +``` + +### `--sustain-sec 0` skips the health check + +Setting `--sustain-sec 0` disables the sustain phase entirely. This is useful for +a pure throughput measurement but means you get no signal on whether VMs remain alive +under density pressure. Do not use `--sustain-sec 0` when trying to characterise +reliability — only when characterising raw boot throughput. + +### Single-run results have significant variance + +Boot times and peak density can vary noticeably between runs due to kernel page cache +state, TAP device setup timing, and SSH handshake jitter. Run each configuration at +least three times and report the median peak and p95 boot time rather than a single +result. From 5b392347da4efb87c74c2c890112b8ac3f841088 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Thu, 5 Mar 2026 22:09:15 -0500 Subject: [PATCH 03/20] added aws exec script --- benchmarks/run_density_ramp_ec2.sh | 318 +++++++++++++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100755 benchmarks/run_density_ramp_ec2.sh diff --git a/benchmarks/run_density_ramp_ec2.sh b/benchmarks/run_density_ramp_ec2.sh new file mode 100755 index 0000000..da69e23 --- /dev/null +++ b/benchmarks/run_density_ramp_ec2.sh @@ -0,0 +1,318 @@ +#!/usr/bin/env bash +# run_density_ramp_ec2.sh +# +# Launches an EC2 instance, deploys and runs the density_ramp benchmark, +# collects results, then terminates the instance. +# +# Prerequisites: +# - AWS CLI configured (aws configure or IAM role) +# - An existing EC2 key pair (set KEY_NAME below or via env) +# - The key's .pem file accessible at KEY_PATH +# +# Usage: +# ./run_density_ramp_ec2.sh [--tier tiny|small|med] [--max-attempts N] \ +# [--sustain-sec N] [--parallel N] [--shared-disk] \ +# [--output FILE] +# +# Environment variable overrides: +# KEY_NAME EC2 key pair name (required) +# KEY_PATH Path to .pem file (default: ~/.ssh/${KEY_NAME}.pem) +# INSTANCE_TYPE EC2 instance type (default: c5.metal) +# AMI_ID AMI to use (default: latest Amazon Linux 2023 in us-east-1) +# REGION AWS region (default: us-east-1) +# SECURITY_GROUP Security group ID (optional; creates a temporary one if unset) +# SUBNET_ID Subnet ID (optional; uses default VPC subnet if unset) + +set -euo pipefail + +# --------------------------------------------------------------------------- +# Defaults (override via environment variables) +# --------------------------------------------------------------------------- +REGION="${REGION:-us-east-1}" +INSTANCE_TYPE="${INSTANCE_TYPE:-c5.metal}" +KEY_NAME="${KEY_NAME:-}" +KEY_PATH="${KEY_PATH:-}" +SECURITY_GROUP="${SECURITY_GROUP:-}" +SUBNET_ID="${SUBNET_ID:-}" +AMI_ID="${AMI_ID:-}" + +# Benchmark args (overridden by CLI flags below) +TIER="tiny" +MAX_ATTEMPTS="500" +SUSTAIN_SEC="60" +PARALLEL="1" +SHARED_DISK="" +OUTPUT_FILE="density_$(date +%Y%m%d_%H%M%S).json" + +# --------------------------------------------------------------------------- +# Parse CLI flags +# --------------------------------------------------------------------------- +while [[ $# -gt 0 ]]; do + case "$1" in + --tier) TIER="$2"; shift 2 ;; + --max-attempts) MAX_ATTEMPTS="$2"; shift 2 ;; + --sustain-sec) SUSTAIN_SEC="$2"; shift 2 ;; + --parallel) PARALLEL="$2"; shift 2 ;; + --shared-disk) SHARED_DISK="--shared-disk"; shift ;; + --output) OUTPUT_FILE="$2"; shift 2 ;; + *) echo "Unknown argument: $1"; exit 1 ;; + esac +done + +# --------------------------------------------------------------------------- +# Validate prerequisites +# --------------------------------------------------------------------------- +if ! command -v aws &>/dev/null; then + echo "ERROR: AWS CLI not found. Install it: https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html" + exit 1 +fi + +if [[ -z "$KEY_NAME" ]]; then + echo "ERROR: KEY_NAME is not set. Export it or edit this script." + echo " export KEY_NAME=my-key-pair" + exit 1 +fi + +KEY_PATH="${KEY_PATH:-$HOME/.ssh/${KEY_NAME}.pem}" +if [[ ! -f "$KEY_PATH" ]]; then + echo "ERROR: Key file not found at $KEY_PATH" + echo " Set KEY_PATH to the correct location of your .pem file." + exit 1 +fi +chmod 600 "$KEY_PATH" + +# --------------------------------------------------------------------------- +# Resolve AMI (latest Amazon Linux 2023 x86_64) +# --------------------------------------------------------------------------- +if [[ -z "$AMI_ID" ]]; then + echo "Resolving latest Amazon Linux 2023 AMI in ${REGION}..." + AMI_ID=$(aws ec2 describe-images \ + --region "$REGION" \ + --owners amazon \ + --filters \ + "Name=name,Values=al2023-ami-2023*-x86_64" \ + "Name=state,Values=available" \ + --query "sort_by(Images, &CreationDate)[-1].ImageId" \ + --output text) + echo "Using AMI: $AMI_ID" +fi + +# --------------------------------------------------------------------------- +# Optionally create a temporary security group +# --------------------------------------------------------------------------- +CREATED_SG="" +if [[ -z "$SECURITY_GROUP" ]]; then + echo "Creating temporary security group..." + SG_NAME="smolvm-bench-$(date +%s)" + + # Get default VPC + DEFAULT_VPC=$(aws ec2 describe-vpcs \ + --region "$REGION" \ + --filters "Name=isDefault,Values=true" \ + --query "Vpcs[0].VpcId" \ + --output text) + + SECURITY_GROUP=$(aws ec2 create-security-group \ + --region "$REGION" \ + --group-name "$SG_NAME" \ + --description "Temporary SG for SmolVM density benchmark" \ + --vpc-id "$DEFAULT_VPC" \ + --query "GroupId" \ + --output text) + + # Allow SSH from anywhere (scope this down if your environment allows it) + aws ec2 authorize-security-group-ingress \ + --region "$REGION" \ + --group-id "$SECURITY_GROUP" \ + --protocol tcp \ + --port 22 \ + --cidr 0.0.0.0/0 \ + >/dev/null + + CREATED_SG="$SECURITY_GROUP" + echo "Created security group: $SECURITY_GROUP" +fi + +# --------------------------------------------------------------------------- +# Launch EC2 instance +# --------------------------------------------------------------------------- +INSTANCE_ID="" + +cleanup() { + echo "" + echo "--- Cleanup ---" + + if [[ -n "$INSTANCE_ID" ]]; then + echo "Terminating instance $INSTANCE_ID..." + aws ec2 terminate-instances \ + --region "$REGION" \ + --instance-ids "$INSTANCE_ID" \ + >/dev/null + echo "Termination requested." + fi + + if [[ -n "$CREATED_SG" ]]; then + echo "Waiting for instance to terminate before deleting security group..." + aws ec2 wait instance-terminated \ + --region "$REGION" \ + --instance-ids "$INSTANCE_ID" 2>/dev/null || true + echo "Deleting security group $CREATED_SG..." + aws ec2 delete-security-group \ + --region "$REGION" \ + --group-id "$CREATED_SG" 2>/dev/null || true + fi +} +trap cleanup EXIT + +echo "" +echo "Launching $INSTANCE_TYPE instance..." + +LAUNCH_ARGS=( + --region "$REGION" + --image-id "$AMI_ID" + --instance-type "$INSTANCE_TYPE" + --key-name "$KEY_NAME" + --security-group-ids "$SECURITY_GROUP" + --count 1 + --instance-initiated-shutdown-behavior terminate + --query "Instances[0].InstanceId" + --output text +) +if [[ -n "$SUBNET_ID" ]]; then + LAUNCH_ARGS+=(--subnet-id "$SUBNET_ID") +fi + +INSTANCE_ID=$(aws ec2 run-instances "${LAUNCH_ARGS[@]}") +echo "Instance ID: $INSTANCE_ID" + +# --------------------------------------------------------------------------- +# Wait for instance to be running and pass status checks +# --------------------------------------------------------------------------- +echo "Waiting for instance to reach 'running' state..." +aws ec2 wait instance-running \ + --region "$REGION" \ + --instance-ids "$INSTANCE_ID" + +echo "Waiting for system status checks to pass..." +aws ec2 wait instance-status-ok \ + --region "$REGION" \ + --instance-ids "$INSTANCE_ID" + +PUBLIC_IP=$(aws ec2 describe-instances \ + --region "$REGION" \ + --instance-ids "$INSTANCE_ID" \ + --query "Reservations[0].Instances[0].PublicIpAddress" \ + --output text) +echo "Instance running at $PUBLIC_IP" + +SSH="ssh -i $KEY_PATH -o StrictHostKeyChecking=no -o ConnectTimeout=10 ec2-user@$PUBLIC_IP" + +# --------------------------------------------------------------------------- +# Wait for SSH to become available +# --------------------------------------------------------------------------- +echo "Waiting for SSH to become available..." +for i in $(seq 1 30); do + if $SSH "echo ok" &>/dev/null; then + echo "SSH is up." + break + fi + if [[ $i -eq 30 ]]; then + echo "ERROR: SSH never became available." + exit 1 + fi + sleep 10 +done + +# --------------------------------------------------------------------------- +# Install dependencies on the instance +# --------------------------------------------------------------------------- +echo "" +echo "--- Installing dependencies ---" +$SSH bash <<'REMOTE' +set -euo pipefail + +# Enable KVM access +sudo usermod -aG kvm ec2-user || true +sudo chmod 666 /dev/kvm + +# Install Python and pip +sudo dnf install -y python3 python3-pip --quiet + +# Install smolvm and psutil +pip3 install --quiet smolvm psutil + +# Trigger Firecracker binary download +smolvm demo list 2>/dev/null || true +REMOTE + +echo "Dependencies installed." + +# --------------------------------------------------------------------------- +# Upload benchmark script +# --------------------------------------------------------------------------- +echo "" +echo "--- Uploading benchmark ---" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +scp -i "$KEY_PATH" -o StrictHostKeyChecking=no \ + "$SCRIPT_DIR/density_ramp.py" \ + "ec2-user@$PUBLIC_IP:~/density_ramp.py" +echo "Uploaded density_ramp.py" + +# --------------------------------------------------------------------------- +# Run benchmark +# --------------------------------------------------------------------------- +REMOTE_OUTPUT="density.json" +BENCHMARK_CMD="python3 ~/density_ramp.py \ + --tier $TIER \ + --max-attempts $MAX_ATTEMPTS \ + --sustain-sec $SUSTAIN_SEC \ + --parallel $PARALLEL \ + ${SHARED_DISK} \ + --output ~/$REMOTE_OUTPUT" + +echo "" +echo "--- Running benchmark ---" +echo " tier=$TIER max-attempts=$MAX_ATTEMPTS sustain-sec=$SUSTAIN_SEC parallel=$PARALLEL ${SHARED_DISK:+shared-disk}" +echo "" + +# Run with a pseudo-TTY so output streams live; failure here still triggers cleanup +$SSH -t "$BENCHMARK_CMD" || { + echo "" + echo "WARNING: Benchmark exited with a non-zero status (may be expected at resource limit)." +} + +# --------------------------------------------------------------------------- +# Collect results +# --------------------------------------------------------------------------- +echo "" +echo "--- Collecting results ---" +scp -i "$KEY_PATH" -o StrictHostKeyChecking=no \ + "ec2-user@$PUBLIC_IP:~/$REMOTE_OUTPUT" \ + "./$OUTPUT_FILE" + +echo "Results saved to: $OUTPUT_FILE" +echo "" +echo "Quick summary:" +python3 - "$OUTPUT_FILE" <<'PYEOF' +import json, sys + +with open(sys.argv[1]) as f: + data = json.load(f) + +boots = [d for d in data if d.get("event") == "boot_ok"] +fails = [d for d in data if d.get("event") == "boot_fail"] +sustain = next((d for d in data if d.get("event") == "sustain_check"), None) + +print(f" Successful boots : {len(boots)}") +print(f" Failed boots : {len(fails)}") +if boots: + times = [d["boot_time_s"] for d in boots] + print(f" Boot time avg : {sum(times)/len(times):.2f}s") + print(f" Boot time max : {max(times):.2f}s") + last = boots[-1] + print(f" Peak mem used : {last['host_mem_used_gb']:.2f} GB") +if sustain: + print(f" Sustain alive : {sustain['vms_alive']}/{sustain['vms_checked']} VMs") +PYEOF + +# Instance is terminated by the cleanup trap on EXIT From 6af109abbee01176df7aa6d15508298219b1b180 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Thu, 5 Mar 2026 22:09:27 -0500 Subject: [PATCH 04/20] updated project deps --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 9cf1b1a..60587e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,6 +28,7 @@ classifiers = [ ] dependencies = [ "paramiko>=3.0", + "psutil>=7.2.2", "pydantic>=2.0", "requests>=2.28", "requests-unixsocket>=0.3", From f91b6bef58a8c10f62450f90ff073147d54dbaab Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Sun, 8 Mar 2026 23:25:18 -0400 Subject: [PATCH 05/20] fix: correct /var/empty ownership in Docker-path rootfs builds When building the ext4 rootfs via _create_ext4_with_docker (used when the loopfs helper is absent, e.g. on a bare pip install on EC2), Python's tar.extractall() runs as a non-root user and cannot chown files to uid=0. This left /var/empty and /etc/ssh owned by the host user's uid in the image. sshd refuses to start if /var/empty is not root-owned, so port 22 never opened and all VM SSH attempts timed out. Fix: before mke2fs reads the source tree, the Docker container (running as root) chowns /var/empty and /etc/ssh to root:root and sets /var/empty to 755. The volume mount is changed from :ro to writable to allow the chown. Also adds diagnostic tooling to density_ramp benchmark: - Print Firecracker log on first boot failure to expose sshd errors - Stop orphaned VM on wait_for_ssh failure (resource leak fix) - EC2 script: disable firewalld (conflicts with SmolVM nftables rules) - EC2 script: post-run diagnostics section (network state + VM log) Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/density_ramp.py | 28 +++- benchmarks/docs/README_DENSITY_RAMP.md | 212 +++++++++++++++++-------- benchmarks/run_density_ramp_ec2.sh | 99 ++++++++++-- src/smolvm/build.py | 13 +- 4 files changed, 277 insertions(+), 75 deletions(-) diff --git a/benchmarks/density_ramp.py b/benchmarks/density_ramp.py index e501be8..417c24b 100644 --- a/benchmarks/density_ramp.py +++ b/benchmarks/density_ramp.py @@ -138,6 +138,18 @@ def build_image( return kernel, rootfs, str(priv_key) +def _read_vm_log(vm: SmolVM, tail_lines: int = 60) -> str: + """Read the Firecracker/QEMU log for a VM (last N lines).""" + try: + log_path = vm.data_dir / f"{vm.vm_id}.log" + if log_path.exists(): + lines = log_path.read_text(errors="replace").splitlines() + return "\n".join(lines[-tail_lines:]) if lines else "(log file is empty)" + return f"(log not found: {log_path})" + except Exception as exc: + return f"(could not read log: {exc})" + + def boot_one( seq: int, kernel: Path, @@ -150,6 +162,7 @@ def boot_one( ) -> tuple[SmolVM | None, float, dict[str, Any]]: """Boot a single VM. Returns (vm_or_None, boot_seconds, error_dict).""" start_t = time.time() + vm: SmolVM | None = None try: config = VMConfig( vm_id=f"vm-{uuid.uuid4().hex[:8]}", @@ -163,9 +176,16 @@ def boot_one( ) vm = SmolVM(config, ssh_key_path=ssh_key_path, socket_dir=socket_dir) vm.start() + vm.wait_for_ssh(timeout=30.0) return vm, time.time() - start_t, {} except Exception as e: - return None, time.time() - start_t, {"error": str(e)} + fc_log = _read_vm_log(vm) if vm is not None else "(VM object not created)" + if vm is not None: + try: + vm.stop() + except Exception: + pass + return None, time.time() - start_t, {"error": str(e), "fc_log": fc_log} def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: @@ -249,6 +269,7 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: kernel, rootfs, ssh_key_path = build_image(tier_config, args.backend) results: list[dict[str, Any]] = [] + _diag_printed = False # Print Firecracker log only for the first failure try: i = 0 @@ -313,6 +334,11 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: ) else: print(f"FAIL @ VM {i}: {err.get('error', '?')}") + if not _diag_printed and err.get("fc_log"): + _diag_printed = True + print("--- Firecracker log (first failure) ---") + print(err["fc_log"]) + print("--- End Firecracker log ---") results.append( { "event": "boot_fail", diff --git a/benchmarks/docs/README_DENSITY_RAMP.md b/benchmarks/docs/README_DENSITY_RAMP.md index e31537d..d57e1af 100644 --- a/benchmarks/docs/README_DENSITY_RAMP.md +++ b/benchmarks/docs/README_DENSITY_RAMP.md @@ -7,69 +7,121 @@ ## Purpose This benchmark helps answer key questions about SmolVM: + - **Maximum concurrent VMs**: How many VMs can run simultaneously on a given system? - **Performance degradation**: How do boot times and system metrics change as density increases? - **Resource utilization**: What are the per-VM resource costs (CPU, memory)? - **Failure modes**: What resource limits cause deployments to fail? -## Usage +## Running on EC2 (Recommended) + +The easiest way to run this benchmark is with the provided `run_density_ramp_ec2.sh` script, which handles provisioning, setup, execution, and cleanup automatically. + +### Prerequisites + +- AWS CLI configured (`aws configure` or IAM role) +- An EC2 key pair with the `.pem` file accessible locally +- The key pair name set in the script or via `KEY_NAME` environment variable + +### Usage + +```bash +cd benchmarks/ +./run_density_ramp_ec2.sh [--tier tiny|small|med] [--max-attempts N] \ + [--sustain-sec N] [--parallel N] [--shared-disk] \ + [--output FILE] +``` + +The script will: + +1. Launch a `c5d.metal` instance (96 vCPUs, 192 GB RAM, 2x 900 GB NVMe) +2. Install all dependencies (Python 3.11, Docker, nftables) +3. Mount the NVMe drive and redirect all SmolVM data to it +4. Upload and run the benchmark +5. Download results to `./density_YYYYMMDD_HHMMSS.json` +6. Print a quick summary +7. Terminate the instance and clean up the security group + +### Environment Variable Overrides + +| Variable | Default | Description | +| -------- | ------- | ----------- | +| `KEY_NAME` | `smolvm-benchmark` | EC2 key pair name | +| `KEY_PATH` | `~/.ssh/${KEY_NAME}.pem` | Path to `.pem` file | +| `INSTANCE_TYPE` | `c5d.metal` | EC2 instance type | +| `REGION` | `us-east-2` | AWS region | +| `SECURITY_GROUP` | _(auto-created)_ | Existing security group ID | +| `SUBNET_ID` | _(default VPC)_ | Subnet ID | +| `AMI_ID` | _(latest AL2023)_ | AMI to use | + +### Instance Type Notes + +The default `c5d.metal` provides: + +- 96 vCPUs, 192 GB RAM +- **2x 900 GB NVMe instance store** — the NVMe is required for disk-intensive runs (isolated mode uses up to 126 GB for 253 tiny VMs) + +To override to a different instance type: `INSTANCE_TYPE=c5.metal ./run_density_ramp_ec2.sh` — but you will need to add a large EBS volume separately or use `--shared-disk`. + +--- + +## Running Locally ### Basic Invocation ```bash -python density_ramp.py --tier tiny --max_attempts 500 +python density_ramp.py --tier tiny --max-attempts 500 ``` ### Arguments | Argument | Type | Default | Description | -|----------|------|---------|-------------| +| -------- | ---- | ------- | ----------- | | `--tier` | `{tiny, small, med}` | `tiny` | VM size configuration tier | -| `--max_attempts` | int | `500` | Maximum number of VMs to launch | -| `--sustain_sec` | int | `60` | Idle duration (seconds) to wait between VM boots for stability check | +| `--max-attempts` | int | `500` | Maximum number of VMs to launch | +| `--sustain-sec` | int | `60` | Idle duration (seconds) after peak density before health-checking all VMs | +| `--parallel` | int | `1` | Number of VMs to boot concurrently per batch | +| `--shared-disk` | flag | off | Use `disk_mode=shared` (no per-VM rootfs clone); saves disk, less isolation | +| `--backend` | string | `auto` | Backend override: `firecracker`, `qemu`, or `auto` | +| `--socket-dir` | path | `/tmp` | Firecracker socket directory | | `--output` | string | `density.json` | Output file path for results (JSON format) | ### VM Tiers Each tier defines VM memory and disk size: -| Tier | Memory | Disk | -|------|--------|------| -| `tiny` | 128 MiB | 512 MiB | -| `small` | 512 MiB | 1 GiB | -| `med` | 2048 MiB | 4 GiB | +| Tier | Memory | Disk | Max disk (isolated, 253 VMs) | +| ---- | ------ | ---- | ---------------------------- | +| `tiny` | 128 MiB | 512 MiB | ~126 GB | +| `small` | 512 MiB | 1 GiB | ~253 GB | +| `med` | 2048 MiB | 4 GiB | ~1 TB | + +> **Tip**: Use `--shared-disk` to eliminate per-VM disk clones entirely when disk space is limited. ## How It Works -1. **Boot Loop**: For each iteration (up to `--max_attempts`): +1. **Boot Loop**: For each iteration (up to `--max-attempts`): - Create a new VM with the specified tier configuration - - Boot it and record boot time - - Keep it running (append to active VM list) - - Wait `--sustain_sec` seconds - - Run a quick liveness check (`sleep 1 && uptime`) + - Boot it and wait for SSH to become ready (up to 30 s) + - Record boot time (includes SSH readiness — this is the true "ready to serve" latency) + - Keep it running with the SSH connection pre-established (append to active VM list) - Capture host metrics (CPU, memory, Firecracker RSS, KVM VM count) -2. **Failure Handling**: If any VM fails to boot or fails the liveness check, the test stops and records the failure point. +2. **Sustain Check**: After the ramp completes (or hits `--max-attempts`), wait `--sustain-sec` seconds then run a liveness check (`uptime`) on all surviving VMs. Because SSH connections are pre-established during boot, the sustain check reuses existing paramiko transports rather than opening 64+ new connections concurrently. -3. **Metrics Collection**: For each successful VM, the benchmark captures: - - Boot time (seconds) - - Timestamp - - Number of VMs running - - Host CPU utilization (%) - - Host memory used (GB) - - Active KVM VM count - - Total Firecracker RSS memory (MB) +3. **Failure Handling**: If any VM fails to boot, the batch is considered failed and the ramp stops. 4. **Cleanup**: On exit (success, failure, or interrupt), all VMs are stopped gracefully. ## Output Format -Results are written to a JSON file (default: `density.json`): +Results are written to a JSON file (default: `density.json`). Each entry represents an event: ```json [ { - "vm_id": 1, + "event": "boot_ok", + "seq": 1, "boot_time_s": 0.45, "timestamp": 1699564800.123, "vms_running": 1, @@ -78,95 +130,131 @@ Results are written to a JSON file (default: `density.json`): "kvm_vms": 1, "firecracker_rss_mb": 156.2 }, - ... { - "failure_at": 245, + "event": "boot_fail", + "seq": 245, "error": "Out of memory", - "timestamp": 1699564900.456, - "vms_running": 244, - "host_cpu_pct": 85.0, - "host_mem_used_gb": 15.8, - "kvm_vms": 244, - "firecracker_rss_mb": 15200.0 + "timestamp": 1699564900.456 + }, + { + "event": "sustain_check", + "vms_checked": 244, + "vms_alive": 244, + "timestamp": 1699564960.789 } ] ``` -## Prerequisites +## Prerequisites (Local) -- Linux system with KVM support +- Linux system with KVM support (`/dev/kvm` accessible) +- Python 3.10+ - SmolVM installed: `pip install smolvm psutil` -- Sufficient disk space for the rootfs/kernel images -- Firecracker binary available on the system +- Docker (for building the Alpine SSH image on first run) +- `nftables` (`nft` command) for VM networking +- Firecracker binary (downloaded automatically via `smolvm.host.HostManager().install_firecracker()`) +- Sufficient disk space (see tier table above; use `--shared-disk` to reduce requirements) ## Example Runs ### Tiny VMs (Max Capacity Test) + ```bash -python density_ramp.py --tier tiny --max_attempts 1000 --sustain_sec 30 --output tiny_density.json +python density_ramp.py --tier tiny --max-attempts 253 --sustain-sec 30 --output tiny_density.json ``` + Good for finding absolute maximum concurrent VM count with minimal overhead. +### Tiny VMs, Parallel Boot + +```bash +python density_ramp.py --tier tiny --max-attempts 253 --parallel 10 --sustain-sec 30 +``` + +Boot 10 VMs at a time to reduce ramp-up time. + ### Small VMs (Realistic Mixed Workload) + ```bash -python density_ramp.py --tier small --max_attempts 100 --sustain_sec 60 --output small_density.json +python density_ramp.py --tier small --max-attempts 100 --sustain-sec 60 --output small_density.json ``` + Realistic for typical application workloads. ### Medium VMs (Headroom Test) + ```bash -python density_ramp.py --tier med --max_attempts 50 --sustain_sec 60 --output med_density.json +python density_ramp.py --tier med --max-attempts 50 --sustain-sec 60 --output med_density.json ``` + Tests system behavior under heavier individual VM loads. +### Shared Disk (Disk-Constrained Systems) + +```bash +python density_ramp.py --tier tiny --max-attempts 253 --shared-disk +``` + +All VMs boot from the same rootfs — no per-VM clone needed. + ## Analysis & Interpretation After running the benchmark: 1. **Look at the final record** to identify the failure point and surrounding metrics -2. **Bootstrap time trend**: Is boot time degrading as VMs accumulate? +2. **Boot time trend**: Is boot time degrading as VMs accumulate? 3. **Memory usage**: How does host memory consumption scale with VM count? 4. **Firecracker RSS**: Individual Firecracker process overhead 5. **CPU contention**: Does CPU utilization increase as density rises? Example analysis (Python): + ```python import json with open('density.json') as f: data = json.load(f) -# Find where it failed -if 'failure_at' in data[-1]: - print(f"Max VMs: {data[-1]['failure_at']}") -else: - print(f"Max VMs: {len(data)}") - -# Boot time trend -boot_times = [d.get('boot_time_s') for d in data if 'boot_time_s' in d] -print(f"Avg boot: {sum(boot_times) / len(boot_times):.2f}s") -print(f"Max boot: {max(boot_times):.2f}s") +boots = [d for d in data if d.get('event') == 'boot_ok'] +fails = [d for d in data if d.get('event') == 'boot_fail'] +sustain = next((d for d in data if d.get('event') == 'sustain_check'), None) + +print(f"Peak VMs : {len(boots)}") +print(f"Failed boots : {len(fails)}") +if boots: + times = [d['boot_time_s'] for d in boots] + print(f"Avg boot time : {sum(times)/len(times):.2f}s") + print(f"Max boot time : {max(times):.2f}s") + print(f"Peak mem used : {boots[-1]['host_mem_used_gb']:.2f} GB") +if sustain: + print(f"Sustain alive : {sustain['vms_alive']}/{sustain['vms_checked']} VMs") ``` ## Notes -- This is a "first draft" benchmark and is maintained in "skepticism mode", meaning results should be interpreted carefully and may vary significantly based on host system configuration -- The liveness check (`sleep 1 && uptime`) ensures VMs remain responsive, not just that they booted +- This is a "first draft" benchmark maintained in "skepticism mode" — results should be interpreted carefully and may vary based on host configuration +- `boot_time_s` includes the time to SSH readiness (not just Firecracker start), making it a true end-to-end "ready to serve" latency +- SSH connections are pre-established during the boot loop; the sustain check reuses these connections via persistent paramiko transports +- The liveness check (`uptime`) ensures VMs remain responsive, not just that they booted - Firecracker RSS includes all Firecracker processes, not per-VM attribution -- The test does not perform VM cleanup between iterations—all VMs remain running until the end -- On macOS, this test will not run (KVM is Linux-only); use a Linux system for density testing +- The test does not perform VM cleanup between iterations — all VMs remain running until the end +- On macOS, this test will not run (KVM is Linux-only); use the EC2 script or a Linux system ## Troubleshooting | Issue | Cause | Solution | -|-------|-------|----------| -| "ERROR: pip install smolvm" | SmolVM not installed | `pip install smolvm psutil` | -| Quick failure (VM 1 or 2) | Missing Firecracker binary | Run `smolvm demo list` to trigger setup | -| High failure rate | Insufficient disk space | Free up space or use smaller tier | -| Inconsistent results | System load variation | Run test with minimal background processes | -| KVM device errors | Permissions issue | Check KVM device permissions (`/dev/kvm`) | +| ----- | ----- | -------- | +| `smolvm` not found | Package not installed | `pip3.11 install smolvm psutil` | +| `nft: command not found` | nftables not installed | `sudo dnf install -y nftables` | +| `Docker is required` | Docker not installed or not running | `sudo dnf install -y docker && sudo systemctl start docker` | +| `Firecracker binary not found` | Firecracker not downloaded | `python3 -c "from smolvm.host import HostManager; HostManager().install_firecracker()"` | +| Quick failure (VM 1) | KVM permissions | `sudo chmod 666 /dev/kvm` and add user to `kvm` group | +| Disk exhaustion warning | Isolated mode fills disk | Use `--shared-disk` or provision more disk (NVMe on `c5d.metal`) | +| All VMs dead in sustain check: `SSH did not become ready` | 64+ concurrent SSH connections opened simultaneously overwhelm paramiko or nftables DNAT under load | Fixed: SSH is now pre-established during the boot loop | +| Inconsistent results | System load variation | Run with minimal background processes | ## See Also - [SmolVM Documentation](../README.md) +- [EC2 Benchmark Script](../run_density_ramp_ec2.sh) - [Other Benchmarks](../) diff --git a/benchmarks/run_density_ramp_ec2.sh b/benchmarks/run_density_ramp_ec2.sh index da69e23..4e1f4b7 100755 --- a/benchmarks/run_density_ramp_ec2.sh +++ b/benchmarks/run_density_ramp_ec2.sh @@ -28,9 +28,9 @@ set -euo pipefail # --------------------------------------------------------------------------- # Defaults (override via environment variables) # --------------------------------------------------------------------------- -REGION="${REGION:-us-east-1}" -INSTANCE_TYPE="${INSTANCE_TYPE:-c5.metal}" -KEY_NAME="${KEY_NAME:-}" +REGION="${REGION:-us-east-2}" +INSTANCE_TYPE="${INSTANCE_TYPE:-c5d.metal}" +KEY_NAME="smolvm-benchmark" #"${KEY_NAME:-}" KEY_PATH="${KEY_PATH:-}" SECURITY_GROUP="${SECURITY_GROUP:-}" SUBNET_ID="${SUBNET_ID:-}" @@ -223,6 +223,17 @@ for i in $(seq 1 30); do sleep 10 done +# --------------------------------------------------------------------------- +# Package smolvm source for upload +# --------------------------------------------------------------------------- +echo "" +echo "--- Packaging smolvm source ---" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)" +SOURCE_TAR="$(mktemp -d)/smolvm-src.tar.gz" +(cd "$REPO_ROOT" && git archive --format=tar.gz HEAD -- src pyproject.toml README.md > "$SOURCE_TAR") +echo "Packaged source: $(basename "$SOURCE_TAR")" + # --------------------------------------------------------------------------- # Install dependencies on the instance # --------------------------------------------------------------------------- @@ -235,16 +246,53 @@ set -euo pipefail sudo usermod -aG kvm ec2-user || true sudo chmod 666 /dev/kvm -# Install Python and pip -sudo dnf install -y python3 python3-pip --quiet +# Raise open-file and process limits for high-density VM runs +echo "ec2-user soft nofile 65536" | sudo tee -a /etc/security/limits.conf +echo "ec2-user hard nofile 65536" | sudo tee -a /etc/security/limits.conf +echo "ec2-user soft nproc 65536" | sudo tee -a /etc/security/limits.conf +echo "ec2-user hard nproc 65536" | sudo tee -a /etc/security/limits.conf +# Allow a large number of concurrent TCP connections +sudo sysctl -w net.ipv4.ip_local_port_range="1024 65535" >/dev/null +sudo sysctl -w net.core.somaxconn=65535 >/dev/null + +# Disable firewalld — it uses the nftables backend and can conflict with +# SmolVM's own nftables rules, blocking TAP device forwarding. +sudo systemctl stop firewalld 2>/dev/null || true +sudo systemctl disable firewalld 2>/dev/null || true + +# Install Python 3.11, pip, and Docker +sudo dnf install -y python3.11 python3.11-pip docker nftables --quiet +sudo systemctl start docker +sudo usermod -aG docker ec2-user + +# Mount NVMe instance store and redirect all smolvm data to it +sudo mkfs.ext4 -F /dev/nvme1n1 +sudo mkdir -p /mnt/nvme +sudo mount /dev/nvme1n1 /mnt/nvme +sudo mkdir -p /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state +sudo chown ec2-user:ec2-user /mnt/nvme /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state +# Image cache (~/.smolvm/images/) → NVMe +ln -sfn /mnt/nvme/smolvm-images /home/ec2-user/.smolvm +# Disk clones (~/.local/state/smolvm/disks/) → NVMe +mkdir -p /home/ec2-user/.local/state +ln -sfn /mnt/nvme/smolvm-state /home/ec2-user/.local/state/smolvm +REMOTE + +scp -i "$KEY_PATH" -o StrictHostKeyChecking=no \ + "$SOURCE_TAR" \ + "ec2-user@$PUBLIC_IP:~/smolvm-src.tar.gz" + +$SSH bash <<'REMOTE' +set -euo pipefail -# Install smolvm and psutil -pip3 install --quiet smolvm psutil +# Install smolvm from source and psutil +pip3.11 install --quiet ~/smolvm-src.tar.gz psutil -# Trigger Firecracker binary download -smolvm demo list 2>/dev/null || true +# Download Firecracker binary +python3.11 -c "from smolvm.host import HostManager; HostManager().install_firecracker()" REMOTE +rm -rf "$(dirname "$SOURCE_TAR")" echo "Dependencies installed." # --------------------------------------------------------------------------- @@ -252,7 +300,6 @@ echo "Dependencies installed." # --------------------------------------------------------------------------- echo "" echo "--- Uploading benchmark ---" -SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" scp -i "$KEY_PATH" -o StrictHostKeyChecking=no \ "$SCRIPT_DIR/density_ramp.py" \ "ec2-user@$PUBLIC_IP:~/density_ramp.py" @@ -262,7 +309,7 @@ echo "Uploaded density_ramp.py" # Run benchmark # --------------------------------------------------------------------------- REMOTE_OUTPUT="density.json" -BENCHMARK_CMD="python3 ~/density_ramp.py \ +BENCHMARK_CMD="python3.11 ~/density_ramp.py \ --tier $TIER \ --max-attempts $MAX_ATTEMPTS \ --sustain-sec $SUSTAIN_SEC \ @@ -281,6 +328,36 @@ $SSH -t "$BENCHMARK_CMD" || { echo "WARNING: Benchmark exited with a non-zero status (may be expected at resource limit)." } +# --------------------------------------------------------------------------- +# Post-run diagnostics (network state + first VM log) +# --------------------------------------------------------------------------- +echo "" +echo "--- Post-run diagnostics ---" +$SSH bash <<'DIAG' || true +set -uo pipefail + +echo "=== Network interfaces (TAP devices) ===" +ip -o link show | grep -E "tap|lo|eth" || true + +echo "" +echo "=== Routes ===" +ip route show + +echo "" +echo "=== nftables ruleset ===" +sudo nft list ruleset 2>/dev/null || echo "(nft list failed)" + +echo "" +echo "=== Most recent Firecracker VM log (last 60 lines) ===" +LOG=$(ls -t ~/.local/state/smolvm/vm-*.log 2>/dev/null | head -1) +if [ -n "$LOG" ]; then + echo "Log: $LOG" + tail -60 "$LOG" +else + echo "(no VM log files found under ~/.local/state/smolvm/)" +fi +DIAG + # --------------------------------------------------------------------------- # Collect results # --------------------------------------------------------------------------- diff --git a/src/smolvm/build.py b/src/smolvm/build.py index 0f70e8e..8a55010 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -703,6 +703,15 @@ def _create_ext4_with_docker( shell_cmd = ( "set -e; " "apk add --no-cache e2fsprogs >/dev/null; " + # When tarball extraction runs as a non-root host user, files that + # should be root-owned (uid=0) end up owned by the host user's uid. + # Fix ownership of sshd-critical paths before mke2fs reads them so + # the resulting ext4 image has the correct inodes. + # /var/empty: sshd privsep dir — must be root:root, not g/o-writable. + # /etc/ssh: host key dir — must be root-owned. + "chown root:root /work/rootfs/var/empty 2>/dev/null || true; " + "chmod 755 /work/rootfs/var/empty 2>/dev/null || true; " + "chown -R root:root /work/rootfs/etc/ssh 2>/dev/null || true; " f"mke2fs -d /work/rootfs -t ext4 -F /work/out/{rootfs_name} " f"{rootfs_size_mb}M >/dev/null" ) @@ -714,7 +723,9 @@ def _create_ext4_with_docker( "run", "--rm", "-v", - f"{rootfs_dir.resolve()}:/work/rootfs:ro", + # Not :ro — the chown step above must be able to modify + # file ownership before mke2fs reads the source tree. + f"{rootfs_dir.resolve()}:/work/rootfs", "-v", f"{rootfs_path.parent.resolve()}:/work/out", "alpine:3.19", From 0ce2073d5c584d63f11d75859d13e3affd7df29c Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Sun, 8 Mar 2026 23:32:15 -0400 Subject: [PATCH 06/20] fix: copy rootfs internally before chown to avoid root-owned temp dir The previous fix chowned /work/rootfs/etc/ssh inside Docker, but that path is a bind-mount from the host's tmpdir. After Docker exits the temp dir has root-owned files that ec2-user cannot remove, causing a PermissionError on TemporaryDirectory cleanup. Fix: cp -a the rootfs to /work/rootfs-fixed inside the container, chown there, and run mke2fs on the copy. The host bind-mount is restored to :ro so the host directory is never modified. Co-Authored-By: Claude Sonnet 4.6 --- src/smolvm/build.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/smolvm/build.py b/src/smolvm/build.py index 8a55010..8b7db17 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -705,14 +705,15 @@ def _create_ext4_with_docker( "apk add --no-cache e2fsprogs >/dev/null; " # When tarball extraction runs as a non-root host user, files that # should be root-owned (uid=0) end up owned by the host user's uid. - # Fix ownership of sshd-critical paths before mke2fs reads them so - # the resulting ext4 image has the correct inodes. + # Copy to an internal path first so we don't modify the host bind-mount + # (which would make the temp dir unremovable by the non-root host user). # /var/empty: sshd privsep dir — must be root:root, not g/o-writable. # /etc/ssh: host key dir — must be root-owned. - "chown root:root /work/rootfs/var/empty 2>/dev/null || true; " - "chmod 755 /work/rootfs/var/empty 2>/dev/null || true; " - "chown -R root:root /work/rootfs/etc/ssh 2>/dev/null || true; " - f"mke2fs -d /work/rootfs -t ext4 -F /work/out/{rootfs_name} " + "cp -a /work/rootfs /work/rootfs-fixed; " + "chown root:root /work/rootfs-fixed/var/empty 2>/dev/null || true; " + "chmod 755 /work/rootfs-fixed/var/empty 2>/dev/null || true; " + "chown -R root:root /work/rootfs-fixed/etc/ssh 2>/dev/null || true; " + f"mke2fs -d /work/rootfs-fixed -t ext4 -F /work/out/{rootfs_name} " f"{rootfs_size_mb}M >/dev/null" ) @@ -723,9 +724,7 @@ def _create_ext4_with_docker( "run", "--rm", "-v", - # Not :ro — the chown step above must be able to modify - # file ownership before mke2fs reads the source tree. - f"{rootfs_dir.resolve()}:/work/rootfs", + f"{rootfs_dir.resolve()}:/work/rootfs:ro", "-v", f"{rootfs_path.parent.resolve()}:/work/out", "alpine:3.19", From 4dc7b2545c56e52d4092e730926173925583ad10 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Sun, 8 Mar 2026 23:46:05 -0400 Subject: [PATCH 07/20] fix: restore rootfs_dir ownership after Docker run to ensure temp dir cleanup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit After mke2fs completes, run a Docker chown pass to restore the ownership of rootfs_dir back to the current user. This prevents PermissionError in TemporaryDirectory cleanup when root-owned files are present — either from the (now-fixed) :ro bypass issue or from residual files left by a previous failed build in the same /tmp path. Co-Authored-By: Claude Sonnet 4.6 --- src/smolvm/build.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/smolvm/build.py b/src/smolvm/build.py index 8b7db17..a66ffd4 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -748,6 +748,30 @@ def _create_ext4_with_docker( if not rootfs_path.exists(): raise ImageError(f"Expected rootfs image not produced: {rootfs_path}") + # Restore ownership of rootfs_dir to the current user so that Python's + # TemporaryDirectory cleanup can remove it. Docker runs as root inside + # the container and, despite the :ro bind-mount, there may be residual + # root-owned files left over from a previous failed build run in the + # same /tmp directory. A cheap chown pass ensures cleanup never fails + # with PermissionError regardless of prior state. + uid, gid = os.getuid(), os.getgid() + subprocess.run( + [ + "docker", + "run", + "--rm", + "-v", + f"{rootfs_dir.resolve()}:/work/rootfs", + "alpine:3.19", + "sh", + "-c", + f"chown -R {uid}:{gid} /work/rootfs 2>/dev/null || true", + ], + check=False, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + def _do_build( self, name: str, From 8e3a79d791a2fd710edfe547c8b93937a4d3a4ff Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Sun, 8 Mar 2026 23:56:02 -0400 Subject: [PATCH 08/20] fix: let Docker extract rootfs tar as root to preserve uid/gid MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Python's tarfile.extractall() silently drops root ownership (uid=0) when the host user is non-root. This caused sshd inside the guest to reject /root/.ssh/authorized_keys (wrong owner) and crash on /var/empty — both paths require root ownership enforced by OpenSSH's strict-modes check. Fix: skip Python's tar extraction entirely. Mount the tarball read-only into a Docker container and let Docker (running as root) extract it with correct uid/gid preserved. Exclude ./dev to avoid CAP_MKNOD failures; the guest init mounts devtmpfs at boot so rootfs device nodes are unused. This also eliminates the rootfs-dir bind-mount that caused root-owned files to appear in the temp dir, so TemporaryDirectory cleanup is clean. Co-Authored-By: Claude Sonnet 4.6 --- src/smolvm/build.py | 69 ++++++++++++++------------------------------- 1 file changed, 21 insertions(+), 48 deletions(-) diff --git a/src/smolvm/build.py b/src/smolvm/build.py index a66ffd4..3060cca 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -678,9 +678,7 @@ def _create_ext4_with_docker( """ logger.info(" [3/4] Creating ext4 filesystem via Docker helper (%dMB)...", rootfs_size_mb) - rootfs_dir = tmpdir / "rootfs-dir" - rootfs_dir.mkdir() - + # Security check: scan tar member paths before Docker extracts them. with tarfile.open(tar_path, "r") as tar: for member in tar.getmembers(): member_path = Path(member.name) @@ -689,31 +687,28 @@ def _create_ext4_with_docker( f"Refusing to extract suspicious tar path from docker export: {member.name}" ) - # Python 3.14 defaults to a restrictive extraction filter that rejects - # absolute symlink targets commonly present in container rootfs archives. - # We already validated member names above, so trusted extraction is safe here. - try: - tar.extractall(path=rootfs_dir, filter="fully_trusted") - except TypeError: - # Python <3.12 does not support the 'filter' argument. - tar.extractall(path=rootfs_dir) - + # Let Docker (running as root) extract the tarball and build the ext4 + # image in a single pass. This preserves the correct uid/gid for every + # file in the container image — Python's tarfile.extractall() silently + # drops root ownership when the host user is non-root, which causes sshd + # to reject /root/.ssh/authorized_keys and crash on /var/empty. + # + # We exclude ./dev to avoid device-node creation (CAP_MKNOD is not + # available without --privileged); the guest init mounts devtmpfs at + # boot so device nodes in the rootfs are not required. rootfs_path.unlink(missing_ok=True) rootfs_name = shlex.quote(rootfs_path.name) + tar_name = shlex.quote(tar_path.name) shell_cmd = ( "set -e; " "apk add --no-cache e2fsprogs >/dev/null; " - # When tarball extraction runs as a non-root host user, files that - # should be root-owned (uid=0) end up owned by the host user's uid. - # Copy to an internal path first so we don't modify the host bind-mount - # (which would make the temp dir unremovable by the non-root host user). - # /var/empty: sshd privsep dir — must be root:root, not g/o-writable. - # /etc/ssh: host key dir — must be root-owned. - "cp -a /work/rootfs /work/rootfs-fixed; " - "chown root:root /work/rootfs-fixed/var/empty 2>/dev/null || true; " - "chmod 755 /work/rootfs-fixed/var/empty 2>/dev/null || true; " - "chown -R root:root /work/rootfs-fixed/etc/ssh 2>/dev/null || true; " - f"mke2fs -d /work/rootfs-fixed -t ext4 -F /work/out/{rootfs_name} " + "mkdir /work/rootfs; " + f"tar xf /work/tar/{tar_name} -C /work/rootfs --exclude=./dev; " + "mkdir -p /work/rootfs/dev; " + # Defensive: guard against edge cases in the Alpine base image. + "chown root:root /work/rootfs/var/empty 2>/dev/null || true; " + "chmod 755 /work/rootfs/var/empty 2>/dev/null || true; " + f"mke2fs -d /work/rootfs -t ext4 -F /work/out/{rootfs_name} " f"{rootfs_size_mb}M >/dev/null" ) @@ -724,7 +719,9 @@ def _create_ext4_with_docker( "run", "--rm", "-v", - f"{rootfs_dir.resolve()}:/work/rootfs:ro", + # tar_path lives inside tmpdir; mount tmpdir read-only so + # Docker can read the tarball without touching the host tree. + f"{tar_path.parent.resolve()}:/work/tar:ro", "-v", f"{rootfs_path.parent.resolve()}:/work/out", "alpine:3.19", @@ -748,30 +745,6 @@ def _create_ext4_with_docker( if not rootfs_path.exists(): raise ImageError(f"Expected rootfs image not produced: {rootfs_path}") - # Restore ownership of rootfs_dir to the current user so that Python's - # TemporaryDirectory cleanup can remove it. Docker runs as root inside - # the container and, despite the :ro bind-mount, there may be residual - # root-owned files left over from a previous failed build run in the - # same /tmp directory. A cheap chown pass ensures cleanup never fails - # with PermissionError regardless of prior state. - uid, gid = os.getuid(), os.getgid() - subprocess.run( - [ - "docker", - "run", - "--rm", - "-v", - f"{rootfs_dir.resolve()}:/work/rootfs", - "alpine:3.19", - "sh", - "-c", - f"chown -R {uid}:{gid} /work/rootfs 2>/dev/null || true", - ], - check=False, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL, - ) - def _do_build( self, name: str, From cda015f9f21f05d9a2ad2e69ba13c998b5ea1756 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 00:49:46 -0400 Subject: [PATCH 09/20] results dir --- .../results/density_20260309_001743.json | 3826 +++++++++++++++++ 1 file changed, 3826 insertions(+) create mode 100644 benchmarks/results/density_20260309_001743.json diff --git a/benchmarks/results/density_20260309_001743.json b/benchmarks/results/density_20260309_001743.json new file mode 100644 index 0000000..d31c445 --- /dev/null +++ b/benchmarks/results/density_20260309_001743.json @@ -0,0 +1,3826 @@ +[ + { + "event": "boot_ok", + "vm_seq": 1, + "boot_time_s": 3.476, + "density_at_boot": 1, + "timestamp": 1773030151.4499836, + "vms_running": 1, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.686443328857422, + "host_disk_used_gb": 2.0351104736328125, + "tap_count": 1, + "firecracker_rss_mb": 46.92578125, + "fc_socket_count": 1, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 2, + "boot_time_s": 3.017, + "density_at_boot": 2, + "timestamp": 1773030154.6498094, + "vms_running": 2, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 2.7395286560058594, + "host_disk_used_gb": 2.0351104736328125, + "tap_count": 2, + "firecracker_rss_mb": 93.59375, + "fc_socket_count": 2, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 3, + "boot_time_s": 2.115, + "density_at_boot": 3, + "timestamp": 1773030156.9101038, + "vms_running": 3, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.7911529541015625, + "host_disk_used_gb": 2.0351715087890625, + "tap_count": 3, + "firecracker_rss_mb": 141.04296875, + "fc_socket_count": 3, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 4, + "boot_time_s": 2.257, + "density_at_boot": 4, + "timestamp": 1773030159.3113978, + "vms_running": 4, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 2.849151611328125, + "host_disk_used_gb": 2.0351715087890625, + "tap_count": 4, + "firecracker_rss_mb": 188.74609375, + "fc_socket_count": 4, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 5, + "boot_time_s": 3.03, + "density_at_boot": 5, + "timestamp": 1773030162.488072, + "vms_running": 5, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.9040756225585938, + "host_disk_used_gb": 2.0352325439453125, + "tap_count": 5, + "firecracker_rss_mb": 235.671875, + "fc_socket_count": 5, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 6, + "boot_time_s": 2.979, + "density_at_boot": 6, + "timestamp": 1773030165.6119142, + "vms_running": 6, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.958332061767578, + "host_disk_used_gb": 2.0352325439453125, + "tap_count": 6, + "firecracker_rss_mb": 282.59765625, + "fc_socket_count": 6, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 7, + "boot_time_s": 2.93, + "density_at_boot": 7, + "timestamp": 1773030168.6872692, + "vms_running": 7, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 3.009899139404297, + "host_disk_used_gb": 2.0352935791015625, + "tap_count": 7, + "firecracker_rss_mb": 329.01171875, + "fc_socket_count": 7, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 8, + "boot_time_s": 3.018, + "density_at_boot": 8, + "timestamp": 1773030171.8506584, + "vms_running": 8, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0595245361328125, + "host_disk_used_gb": 2.0352935791015625, + "tap_count": 8, + "firecracker_rss_mb": 375.9375, + "fc_socket_count": 8, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 9, + "boot_time_s": 2.972, + "density_at_boot": 9, + "timestamp": 1773030174.9678557, + "vms_running": 9, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.119335174560547, + "host_disk_used_gb": 2.0353546142578125, + "tap_count": 9, + "firecracker_rss_mb": 422.8671875, + "fc_socket_count": 9, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 10, + "boot_time_s": 2.933, + "density_at_boot": 10, + "timestamp": 1773030178.0462797, + "vms_running": 10, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.1758041381835938, + "host_disk_used_gb": 2.0353546142578125, + "tap_count": 10, + "firecracker_rss_mb": 469.80078125, + "fc_socket_count": 10, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 11, + "boot_time_s": 3.016, + "density_at_boot": 11, + "timestamp": 1773030181.2088463, + "vms_running": 11, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.226818084716797, + "host_disk_used_gb": 2.0354156494140625, + "tap_count": 11, + "firecracker_rss_mb": 516.21484375, + "fc_socket_count": 11, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 12, + "boot_time_s": 2.973, + "density_at_boot": 12, + "timestamp": 1773030184.3311768, + "vms_running": 12, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.2716827392578125, + "host_disk_used_gb": 2.0354156494140625, + "tap_count": 12, + "firecracker_rss_mb": 563.66015625, + "fc_socket_count": 12, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 13, + "boot_time_s": 3.052, + "density_at_boot": 13, + "timestamp": 1773030187.5301793, + "vms_running": 13, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.3329925537109375, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 13, + "firecracker_rss_mb": 610.328125, + "fc_socket_count": 13, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 14, + "boot_time_s": 2.929, + "density_at_boot": 14, + "timestamp": 1773030190.6060467, + "vms_running": 14, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.3888587951660156, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 14, + "firecracker_rss_mb": 658.03125, + "fc_socket_count": 14, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 15, + "boot_time_s": 3.019, + "density_at_boot": 15, + "timestamp": 1773030193.7698424, + "vms_running": 15, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.4387664794921875, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 15, + "firecracker_rss_mb": 705.73046875, + "fc_socket_count": 15, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 16, + "boot_time_s": 2.932, + "density_at_boot": 16, + "timestamp": 1773030196.8478305, + "vms_running": 16, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.4878005981445312, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 16, + "firecracker_rss_mb": 752.6640625, + "fc_socket_count": 16, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 17, + "boot_time_s": 3.018, + "density_at_boot": 17, + "timestamp": 1773030200.0110958, + "vms_running": 17, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.545806884765625, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 17, + "firecracker_rss_mb": 799.3359375, + "fc_socket_count": 17, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 18, + "boot_time_s": 2.974, + "density_at_boot": 18, + "timestamp": 1773030203.13211, + "vms_running": 18, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.587860107421875, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 18, + "firecracker_rss_mb": 846.5234375, + "fc_socket_count": 18, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 19, + "boot_time_s": 2.056, + "density_at_boot": 19, + "timestamp": 1773030205.3356764, + "vms_running": 19, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.651355743408203, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 19, + "firecracker_rss_mb": 893.96484375, + "fc_socket_count": 19, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 20, + "boot_time_s": 2.974, + "density_at_boot": 20, + "timestamp": 1773030208.4570715, + "vms_running": 20, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 3.710704803466797, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 20, + "firecracker_rss_mb": 941.6640625, + "fc_socket_count": 20, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 21, + "boot_time_s": 3.009, + "density_at_boot": 21, + "timestamp": 1773030211.6118374, + "vms_running": 21, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.7615509033203125, + "host_disk_used_gb": 2.0359039306640625, + "tap_count": 21, + "firecracker_rss_mb": 989.109375, + "fc_socket_count": 21, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 22, + "boot_time_s": 2.069, + "density_at_boot": 22, + "timestamp": 1773030213.8284674, + "vms_running": 22, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.8169288635253906, + "host_disk_used_gb": 2.0359268188476562, + "tap_count": 22, + "firecracker_rss_mb": 1036.80078125, + "fc_socket_count": 22, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 23, + "boot_time_s": 3.078, + "density_at_boot": 23, + "timestamp": 1773030217.0511816, + "vms_running": 23, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.870014190673828, + "host_disk_used_gb": 2.0358848571777344, + "tap_count": 23, + "firecracker_rss_mb": 1083.46875, + "fc_socket_count": 23, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 24, + "boot_time_s": 2.93, + "density_at_boot": 24, + "timestamp": 1773030220.1277292, + "vms_running": 24, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.9227828979492188, + "host_disk_used_gb": 2.0358848571777344, + "tap_count": 24, + "firecracker_rss_mb": 1130.65625, + "fc_socket_count": 24, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 25, + "boot_time_s": 2.235, + "density_at_boot": 25, + "timestamp": 1773030222.5083845, + "vms_running": 25, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.972370147705078, + "host_disk_used_gb": 2.0358848571777344, + "tap_count": 25, + "firecracker_rss_mb": 1177.3203125, + "fc_socket_count": 25, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 26, + "boot_time_s": 2.99, + "density_at_boot": 26, + "timestamp": 1773030225.6468253, + "vms_running": 26, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 4.025539398193359, + "host_disk_used_gb": 2.0358848571777344, + "tap_count": 26, + "firecracker_rss_mb": 1224.765625, + "fc_socket_count": 26, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 27, + "boot_time_s": 3.097, + "density_at_boot": 27, + "timestamp": 1773030228.8900096, + "vms_running": 27, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.0738067626953125, + "host_disk_used_gb": 2.0358657836914062, + "tap_count": 27, + "firecracker_rss_mb": 1271.17578125, + "fc_socket_count": 27, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 28, + "boot_time_s": 3.141, + "density_at_boot": 28, + "timestamp": 1773030232.1799617, + "vms_running": 28, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 4.126220703125, + "host_disk_used_gb": 2.0358657836914062, + "tap_count": 28, + "firecracker_rss_mb": 1318.1015625, + "fc_socket_count": 28, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 29, + "boot_time_s": 3.047, + "density_at_boot": 29, + "timestamp": 1773030235.3704205, + "vms_running": 29, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.184684753417969, + "host_disk_used_gb": 2.0368423461914062, + "tap_count": 29, + "firecracker_rss_mb": 1365.546875, + "fc_socket_count": 29, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 30, + "boot_time_s": 2.931, + "density_at_boot": 30, + "timestamp": 1773030238.448102, + "vms_running": 30, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.227451324462891, + "host_disk_used_gb": 2.0368423461914062, + "tap_count": 30, + "firecracker_rss_mb": 1413.25, + "fc_socket_count": 30, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 31, + "boot_time_s": 3.055, + "density_at_boot": 31, + "timestamp": 1773030241.648236, + "vms_running": 31, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.283435821533203, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 31, + "firecracker_rss_mb": 1460.17578125, + "fc_socket_count": 31, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 32, + "boot_time_s": 2.971, + "density_at_boot": 32, + "timestamp": 1773030244.7659106, + "vms_running": 32, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.325809478759766, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 32, + "firecracker_rss_mb": 1507.87890625, + "fc_socket_count": 32, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 33, + "boot_time_s": 3.019, + "density_at_boot": 33, + "timestamp": 1773030247.929167, + "vms_running": 33, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.375846862792969, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 33, + "firecracker_rss_mb": 1554.8046875, + "fc_socket_count": 33, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 34, + "boot_time_s": 3.011, + "density_at_boot": 34, + "timestamp": 1773030251.087229, + "vms_running": 34, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 4.419551849365234, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 34, + "firecracker_rss_mb": 1601.7265625, + "fc_socket_count": 34, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 35, + "boot_time_s": 3.015, + "density_at_boot": 35, + "timestamp": 1773030254.2502804, + "vms_running": 35, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.469638824462891, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 35, + "firecracker_rss_mb": 1648.140625, + "fc_socket_count": 35, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 36, + "boot_time_s": 2.972, + "density_at_boot": 36, + "timestamp": 1773030257.3696184, + "vms_running": 36, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.522861480712891, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 36, + "firecracker_rss_mb": 1694.80859375, + "fc_socket_count": 36, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 37, + "boot_time_s": 2.931, + "density_at_boot": 37, + "timestamp": 1773030260.4480922, + "vms_running": 37, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.574893951416016, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 37, + "firecracker_rss_mb": 1742.0, + "fc_socket_count": 37, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 38, + "boot_time_s": 3.013, + "density_at_boot": 38, + "timestamp": 1773030263.6088576, + "vms_running": 38, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.616920471191406, + "host_disk_used_gb": 2.036846160888672, + "tap_count": 38, + "firecracker_rss_mb": 1788.671875, + "fc_socket_count": 38, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 39, + "boot_time_s": 2.112, + "density_at_boot": 39, + "timestamp": 1773030265.8692183, + "vms_running": 39, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.669769287109375, + "host_disk_used_gb": 2.044658660888672, + "tap_count": 39, + "firecracker_rss_mb": 1835.08203125, + "fc_socket_count": 39, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 40, + "boot_time_s": 3.031, + "density_at_boot": 40, + "timestamp": 1773030269.0514448, + "vms_running": 40, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.712181091308594, + "host_disk_used_gb": 2.044658660888672, + "tap_count": 40, + "firecracker_rss_mb": 1882.52734375, + "fc_socket_count": 40, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 41, + "boot_time_s": 2.11, + "density_at_boot": 41, + "timestamp": 1773030271.3120732, + "vms_running": 41, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.763164520263672, + "host_disk_used_gb": 2.044658660888672, + "tap_count": 41, + "firecracker_rss_mb": 1929.45703125, + "fc_socket_count": 41, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 42, + "boot_time_s": 2.054, + "density_at_boot": 42, + "timestamp": 1773030273.51748, + "vms_running": 42, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 4.8074798583984375, + "host_disk_used_gb": 2.044658660888672, + "tap_count": 42, + "firecracker_rss_mb": 1976.90234375, + "fc_socket_count": 42, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 43, + "boot_time_s": 3.143, + "density_at_boot": 43, + "timestamp": 1773030276.8104312, + "vms_running": 43, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.8608245849609375, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 43, + "firecracker_rss_mb": 2023.3125, + "fc_socket_count": 43, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 44, + "boot_time_s": 3.047, + "density_at_boot": 44, + "timestamp": 1773030280.0094585, + "vms_running": 44, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.910457611083984, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 44, + "firecracker_rss_mb": 2070.75390625, + "fc_socket_count": 44, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 45, + "boot_time_s": 3.133, + "density_at_boot": 45, + "timestamp": 1773030283.289295, + "vms_running": 45, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.958141326904297, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 45, + "firecracker_rss_mb": 2117.42578125, + "fc_socket_count": 45, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 46, + "boot_time_s": 3.168, + "density_at_boot": 46, + "timestamp": 1773030286.6071842, + "vms_running": 46, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.001457214355469, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 46, + "firecracker_rss_mb": 2164.609375, + "fc_socket_count": 46, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 47, + "boot_time_s": 3.012, + "density_at_boot": 47, + "timestamp": 1773030289.7695093, + "vms_running": 47, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.0518341064453125, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 47, + "firecracker_rss_mb": 2211.53515625, + "fc_socket_count": 47, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 48, + "boot_time_s": 3.049, + "density_at_boot": 48, + "timestamp": 1773030292.96944, + "vms_running": 48, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.094669342041016, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 48, + "firecracker_rss_mb": 2258.20703125, + "fc_socket_count": 48, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 49, + "boot_time_s": 3.051, + "density_at_boot": 49, + "timestamp": 1773030296.1715212, + "vms_running": 49, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.140800476074219, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 49, + "firecracker_rss_mb": 2305.13671875, + "fc_socket_count": 49, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 50, + "boot_time_s": 3.05, + "density_at_boot": 50, + "timestamp": 1773030299.372849, + "vms_running": 50, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.188892364501953, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 50, + "firecracker_rss_mb": 2353.09375, + "fc_socket_count": 50, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 51, + "boot_time_s": 3.046, + "density_at_boot": 51, + "timestamp": 1773030302.5714993, + "vms_running": 51, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.234947204589844, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 51, + "firecracker_rss_mb": 2400.27734375, + "fc_socket_count": 51, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 52, + "boot_time_s": 2.969, + "density_at_boot": 52, + "timestamp": 1773030305.691596, + "vms_running": 52, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.279937744140625, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 52, + "firecracker_rss_mb": 2447.203125, + "fc_socket_count": 52, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 53, + "boot_time_s": 2.106, + "density_at_boot": 53, + "timestamp": 1773030307.9493294, + "vms_running": 53, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.32672119140625, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 53, + "firecracker_rss_mb": 2493.875, + "fc_socket_count": 53, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 54, + "boot_time_s": 2.986, + "density_at_boot": 54, + "timestamp": 1773030311.0870476, + "vms_running": 54, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.3830413818359375, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 54, + "firecracker_rss_mb": 2541.57421875, + "fc_socket_count": 54, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 55, + "boot_time_s": 3.013, + "density_at_boot": 55, + "timestamp": 1773030314.2510355, + "vms_running": 55, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.427848815917969, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 55, + "firecracker_rss_mb": 2588.5, + "fc_socket_count": 55, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 56, + "boot_time_s": 3.048, + "density_at_boot": 56, + "timestamp": 1773030317.4508066, + "vms_running": 56, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.4666900634765625, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 56, + "firecracker_rss_mb": 2635.68359375, + "fc_socket_count": 56, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 57, + "boot_time_s": 2.968, + "density_at_boot": 57, + "timestamp": 1773030320.5722733, + "vms_running": 57, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.512035369873047, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 57, + "firecracker_rss_mb": 2683.125, + "fc_socket_count": 57, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 58, + "boot_time_s": 3.045, + "density_at_boot": 58, + "timestamp": 1773030323.770579, + "vms_running": 58, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.568767547607422, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 58, + "firecracker_rss_mb": 2730.5625, + "fc_socket_count": 58, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 59, + "boot_time_s": 3.046, + "density_at_boot": 59, + "timestamp": 1773030326.9697428, + "vms_running": 59, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.609596252441406, + "host_disk_used_gb": 2.0446548461914062, + "tap_count": 59, + "firecracker_rss_mb": 2777.234375, + "fc_socket_count": 59, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 60, + "boot_time_s": 3.128, + "density_at_boot": 60, + "timestamp": 1773030330.2500215, + "vms_running": 60, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.655048370361328, + "host_disk_used_gb": 2.0466079711914062, + "tap_count": 60, + "firecracker_rss_mb": 2824.1640625, + "fc_socket_count": 60, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 61, + "boot_time_s": 3.045, + "density_at_boot": 61, + "timestamp": 1773030333.4491975, + "vms_running": 61, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.709114074707031, + "host_disk_used_gb": 2.0466079711914062, + "tap_count": 61, + "firecracker_rss_mb": 2871.08984375, + "fc_socket_count": 61, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 62, + "boot_time_s": 2.133, + "density_at_boot": 62, + "timestamp": 1773030335.737336, + "vms_running": 62, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 5.753002166748047, + "host_disk_used_gb": 2.0466079711914062, + "tap_count": 62, + "firecracker_rss_mb": 2917.5, + "fc_socket_count": 62, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 63, + "boot_time_s": 3.082, + "density_at_boot": 63, + "timestamp": 1773030338.9716988, + "vms_running": 63, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.805698394775391, + "host_disk_used_gb": 2.0466079711914062, + "tap_count": 63, + "firecracker_rss_mb": 2964.6875, + "fc_socket_count": 63, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 64, + "boot_time_s": 3.122, + "density_at_boot": 64, + "timestamp": 1773030342.249478, + "vms_running": 64, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.852519989013672, + "host_disk_used_gb": 2.046611785888672, + "tap_count": 64, + "firecracker_rss_mb": 3011.6171875, + "fc_socket_count": 64, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 65, + "boot_time_s": 3.046, + "density_at_boot": 65, + "timestamp": 1773030345.4513075, + "vms_running": 65, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.89459228515625, + "host_disk_used_gb": 2.0466346740722656, + "tap_count": 65, + "firecracker_rss_mb": 3058.5390625, + "fc_socket_count": 65, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 66, + "boot_time_s": 2.161, + "density_at_boot": 66, + "timestamp": 1773030347.7697043, + "vms_running": 66, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.9460906982421875, + "host_disk_used_gb": 2.0466346740722656, + "tap_count": 66, + "firecracker_rss_mb": 3105.7265625, + "fc_socket_count": 66, + "sqlite_db_kb": 104.0 + }, + { + "event": "boot_ok", + "vm_seq": 67, + "boot_time_s": 3.206, + "density_at_boot": 67, + "timestamp": 1773030351.1298063, + "vms_running": 67, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.993007659912109, + "host_disk_used_gb": 2.0466346740722656, + "tap_count": 67, + "firecracker_rss_mb": 3152.9140625, + "fc_socket_count": 67, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 68, + "boot_time_s": 2.084, + "density_at_boot": 68, + "timestamp": 1773030353.371058, + "vms_running": 68, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.039974212646484, + "host_disk_used_gb": 2.0466346740722656, + "tap_count": 68, + "firecracker_rss_mb": 3200.1015625, + "fc_socket_count": 68, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 69, + "boot_time_s": 2.048, + "density_at_boot": 69, + "timestamp": 1773030355.576164, + "vms_running": 69, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.083442687988281, + "host_disk_used_gb": 2.0466346740722656, + "tap_count": 69, + "firecracker_rss_mb": 3246.76953125, + "fc_socket_count": 69, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 70, + "boot_time_s": 3.08, + "density_at_boot": 70, + "timestamp": 1773030358.8102856, + "vms_running": 70, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.127902984619141, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 70, + "firecracker_rss_mb": 3293.703125, + "fc_socket_count": 70, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 71, + "boot_time_s": 3.043, + "density_at_boot": 71, + "timestamp": 1773030362.0093975, + "vms_running": 71, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.174079895019531, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 71, + "firecracker_rss_mb": 3340.890625, + "fc_socket_count": 71, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 72, + "boot_time_s": 2.106, + "density_at_boot": 72, + "timestamp": 1773030364.2694788, + "vms_running": 72, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 6.221134185791016, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 72, + "firecracker_rss_mb": 3388.078125, + "fc_socket_count": 72, + "sqlite_db_kb": 108.0 + }, + { + "event": "boot_ok", + "vm_seq": 73, + "boot_time_s": 3.027, + "density_at_boot": 73, + "timestamp": 1773030367.4498286, + "vms_running": 73, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.259243011474609, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 73, + "firecracker_rss_mb": 3434.75, + "fc_socket_count": 73, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 74, + "boot_time_s": 3.003, + "density_at_boot": 74, + "timestamp": 1773030370.60756, + "vms_running": 74, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 6.309257507324219, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 74, + "firecracker_rss_mb": 3482.70703125, + "fc_socket_count": 74, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 75, + "boot_time_s": 3.091, + "density_at_boot": 75, + "timestamp": 1773030373.8524258, + "vms_running": 75, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.356410980224609, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 75, + "firecracker_rss_mb": 3529.6328125, + "fc_socket_count": 75, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 76, + "boot_time_s": 3.042, + "density_at_boot": 76, + "timestamp": 1773030377.0512536, + "vms_running": 76, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.398593902587891, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 76, + "firecracker_rss_mb": 3576.30078125, + "fc_socket_count": 76, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 77, + "boot_time_s": 3.042, + "density_at_boot": 77, + "timestamp": 1773030380.2496924, + "vms_running": 77, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.446514129638672, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 77, + "firecracker_rss_mb": 3623.48828125, + "fc_socket_count": 77, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 78, + "boot_time_s": 3.045, + "density_at_boot": 78, + "timestamp": 1773030383.449578, + "vms_running": 78, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.494434356689453, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 78, + "firecracker_rss_mb": 3670.67578125, + "fc_socket_count": 78, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 79, + "boot_time_s": 3.044, + "density_at_boot": 79, + "timestamp": 1773030386.6508563, + "vms_running": 79, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.528438568115234, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 79, + "firecracker_rss_mb": 3717.6015625, + "fc_socket_count": 79, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 80, + "boot_time_s": 3.043, + "density_at_boot": 80, + "timestamp": 1773030389.8509417, + "vms_running": 80, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.581905364990234, + "host_disk_used_gb": 2.0466156005859375, + "tap_count": 80, + "firecracker_rss_mb": 3764.01171875, + "fc_socket_count": 80, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 81, + "boot_time_s": 2.997, + "density_at_boot": 81, + "timestamp": 1773030393.0078764, + "vms_running": 81, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.63055419921875, + "host_disk_used_gb": 2.0466384887695312, + "tap_count": 81, + "firecracker_rss_mb": 3810.6796875, + "fc_socket_count": 81, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 82, + "boot_time_s": 2.126, + "density_at_boot": 82, + "timestamp": 1773030395.2907133, + "vms_running": 82, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.671733856201172, + "host_disk_used_gb": 2.0466384887695312, + "tap_count": 82, + "firecracker_rss_mb": 3857.08984375, + "fc_socket_count": 82, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 83, + "boot_time_s": 3.122, + "density_at_boot": 83, + "timestamp": 1773030398.5717978, + "vms_running": 83, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.717853546142578, + "host_disk_used_gb": 2.0466384887695312, + "tap_count": 83, + "firecracker_rss_mb": 3903.5, + "fc_socket_count": 83, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 84, + "boot_time_s": 3.042, + "density_at_boot": 84, + "timestamp": 1773030401.7711225, + "vms_running": 84, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.760826110839844, + "host_disk_used_gb": 2.0466384887695312, + "tap_count": 84, + "firecracker_rss_mb": 3950.68359375, + "fc_socket_count": 84, + "sqlite_db_kb": 124.0 + }, + { + "event": "boot_ok", + "vm_seq": 85, + "boot_time_s": 3.043, + "density_at_boot": 85, + "timestamp": 1773030404.9720445, + "vms_running": 85, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.809974670410156, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 85, + "firecracker_rss_mb": 3997.35546875, + "fc_socket_count": 85, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 86, + "boot_time_s": 2.079, + "density_at_boot": 86, + "timestamp": 1773030407.2089183, + "vms_running": 86, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.854888916015625, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 86, + "firecracker_rss_mb": 4043.765625, + "fc_socket_count": 86, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 87, + "boot_time_s": 3.121, + "density_at_boot": 87, + "timestamp": 1773030410.490603, + "vms_running": 87, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.8976898193359375, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 87, + "firecracker_rss_mb": 4090.6953125, + "fc_socket_count": 87, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 88, + "boot_time_s": 3.204, + "density_at_boot": 88, + "timestamp": 1773030413.8518996, + "vms_running": 88, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.943305969238281, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 88, + "firecracker_rss_mb": 4137.62109375, + "fc_socket_count": 88, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 89, + "boot_time_s": 3.115, + "density_at_boot": 89, + "timestamp": 1773030417.1286414, + "vms_running": 89, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.985912322998047, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 89, + "firecracker_rss_mb": 4184.29296875, + "fc_socket_count": 89, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 90, + "boot_time_s": 3.122, + "density_at_boot": 90, + "timestamp": 1773030420.4100835, + "vms_running": 90, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.030841827392578, + "host_disk_used_gb": 2.046642303466797, + "tap_count": 90, + "firecracker_rss_mb": 4230.70703125, + "fc_socket_count": 90, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 91, + "boot_time_s": 3.043, + "density_at_boot": 91, + "timestamp": 1773030423.6119673, + "vms_running": 91, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.0834808349609375, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 91, + "firecracker_rss_mb": 4277.375, + "fc_socket_count": 91, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 92, + "boot_time_s": 2.263, + "density_at_boot": 92, + "timestamp": 1773030426.0323734, + "vms_running": 92, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.128719329833984, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 92, + "firecracker_rss_mb": 4324.81640625, + "fc_socket_count": 92, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 93, + "boot_time_s": 2.977, + "density_at_boot": 93, + "timestamp": 1773030429.1687467, + "vms_running": 93, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.167278289794922, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 93, + "firecracker_rss_mb": 4371.48828125, + "fc_socket_count": 93, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 94, + "boot_time_s": 3.164, + "density_at_boot": 94, + "timestamp": 1773030432.4911287, + "vms_running": 94, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.213123321533203, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 94, + "firecracker_rss_mb": 4418.67578125, + "fc_socket_count": 94, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 95, + "boot_time_s": 3.04, + "density_at_boot": 95, + "timestamp": 1773030435.6898105, + "vms_running": 95, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 7.2559356689453125, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 95, + "firecracker_rss_mb": 4465.34375, + "fc_socket_count": 95, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 96, + "boot_time_s": 3.204, + "density_at_boot": 96, + "timestamp": 1773030439.0509996, + "vms_running": 96, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.304416656494141, + "host_disk_used_gb": 2.0466232299804688, + "tap_count": 96, + "firecracker_rss_mb": 4512.015625, + "fc_socket_count": 96, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 97, + "boot_time_s": 3.048, + "density_at_boot": 97, + "timestamp": 1773030442.2581456, + "vms_running": 97, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.358158111572266, + "host_disk_used_gb": 2.0466461181640625, + "tap_count": 97, + "firecracker_rss_mb": 4558.94140625, + "fc_socket_count": 97, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 98, + "boot_time_s": 3.115, + "density_at_boot": 98, + "timestamp": 1773030445.5299532, + "vms_running": 98, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.401889801025391, + "host_disk_used_gb": 2.0466461181640625, + "tap_count": 98, + "firecracker_rss_mb": 4606.38671875, + "fc_socket_count": 98, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 99, + "boot_time_s": 3.046, + "density_at_boot": 99, + "timestamp": 1773030448.7335317, + "vms_running": 99, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.446315765380859, + "host_disk_used_gb": 2.0466461181640625, + "tap_count": 99, + "firecracker_rss_mb": 4653.83203125, + "fc_socket_count": 99, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 100, + "boot_time_s": 3.041, + "density_at_boot": 100, + "timestamp": 1773030451.9317963, + "vms_running": 100, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.496425628662109, + "host_disk_used_gb": 2.0466461181640625, + "tap_count": 100, + "firecracker_rss_mb": 4700.5, + "fc_socket_count": 100, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 101, + "boot_time_s": 2.138, + "density_at_boot": 101, + "timestamp": 1773030454.2258134, + "vms_running": 101, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.546222686767578, + "host_disk_used_gb": 2.0466461181640625, + "tap_count": 101, + "firecracker_rss_mb": 4748.4609375, + "fc_socket_count": 101, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 102, + "boot_time_s": 3.073, + "density_at_boot": 102, + "timestamp": 1773030457.451235, + "vms_running": 102, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.5894927978515625, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 102, + "firecracker_rss_mb": 4794.87109375, + "fc_socket_count": 102, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 103, + "boot_time_s": 2.194, + "density_at_boot": 103, + "timestamp": 1773030459.801489, + "vms_running": 103, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.636894226074219, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 103, + "firecracker_rss_mb": 4842.0546875, + "fc_socket_count": 103, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 104, + "boot_time_s": 3.172, + "density_at_boot": 104, + "timestamp": 1773030463.1279225, + "vms_running": 104, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.676593780517578, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 104, + "firecracker_rss_mb": 4888.72265625, + "fc_socket_count": 104, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 105, + "boot_time_s": 3.003, + "density_at_boot": 105, + "timestamp": 1773030466.287735, + "vms_running": 105, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.724208831787109, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 105, + "firecracker_rss_mb": 4936.42578125, + "fc_socket_count": 105, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 106, + "boot_time_s": 3.087, + "density_at_boot": 106, + "timestamp": 1773030469.5299685, + "vms_running": 106, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.775714874267578, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 106, + "firecracker_rss_mb": 4983.3515625, + "fc_socket_count": 106, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 107, + "boot_time_s": 3.123, + "density_at_boot": 107, + "timestamp": 1773030472.8123348, + "vms_running": 107, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.826240539550781, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 107, + "firecracker_rss_mb": 5030.27734375, + "fc_socket_count": 107, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 108, + "boot_time_s": 3.202, + "density_at_boot": 108, + "timestamp": 1773030476.1711428, + "vms_running": 108, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.882148742675781, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 108, + "firecracker_rss_mb": 5076.69140625, + "fc_socket_count": 108, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 109, + "boot_time_s": 2.184, + "density_at_boot": 109, + "timestamp": 1773030478.512836, + "vms_running": 109, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.934665679931641, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 109, + "firecracker_rss_mb": 5124.13671875, + "fc_socket_count": 109, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 110, + "boot_time_s": 2.977, + "density_at_boot": 110, + "timestamp": 1773030481.6478655, + "vms_running": 110, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.981426239013672, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 110, + "firecracker_rss_mb": 5171.0625, + "fc_socket_count": 110, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 111, + "boot_time_s": 3.081, + "density_at_boot": 111, + "timestamp": 1773030484.8901343, + "vms_running": 111, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.023605346679688, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 111, + "firecracker_rss_mb": 5218.24609375, + "fc_socket_count": 111, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 112, + "boot_time_s": 3.117, + "density_at_boot": 112, + "timestamp": 1773030488.168403, + "vms_running": 112, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.06637954711914, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 112, + "firecracker_rss_mb": 5265.42578125, + "fc_socket_count": 112, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 113, + "boot_time_s": 3.122, + "density_at_boot": 113, + "timestamp": 1773030491.4480917, + "vms_running": 113, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 8.119144439697266, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 113, + "firecracker_rss_mb": 5312.3515625, + "fc_socket_count": 113, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 114, + "boot_time_s": 3.122, + "density_at_boot": 114, + "timestamp": 1773030494.7311392, + "vms_running": 114, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.159713745117188, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 114, + "firecracker_rss_mb": 5358.7578125, + "fc_socket_count": 114, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 115, + "boot_time_s": 3.281, + "density_at_boot": 115, + "timestamp": 1773030498.170372, + "vms_running": 115, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 8.206192016601562, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 115, + "firecracker_rss_mb": 5405.171875, + "fc_socket_count": 115, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 116, + "boot_time_s": 2.136, + "density_at_boot": 116, + "timestamp": 1773030500.4652536, + "vms_running": 116, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.25857162475586, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 116, + "firecracker_rss_mb": 5452.10546875, + "fc_socket_count": 116, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 117, + "boot_time_s": 3.227, + "density_at_boot": 117, + "timestamp": 1773030503.8517723, + "vms_running": 117, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.298316955566406, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 117, + "firecracker_rss_mb": 5499.03515625, + "fc_socket_count": 117, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 118, + "boot_time_s": 3.118, + "density_at_boot": 118, + "timestamp": 1773030507.1285613, + "vms_running": 118, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 8.353229522705078, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 118, + "firecracker_rss_mb": 5546.22265625, + "fc_socket_count": 118, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 119, + "boot_time_s": 3.284, + "density_at_boot": 119, + "timestamp": 1773030510.5695388, + "vms_running": 119, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.397003173828125, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 119, + "firecracker_rss_mb": 5592.6328125, + "fc_socket_count": 119, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 120, + "boot_time_s": 3.043, + "density_at_boot": 120, + "timestamp": 1773030513.7708027, + "vms_running": 120, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.439407348632812, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 120, + "firecracker_rss_mb": 5639.5546875, + "fc_socket_count": 120, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 121, + "boot_time_s": 2.183, + "density_at_boot": 121, + "timestamp": 1773030516.1103702, + "vms_running": 121, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.481975555419922, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 121, + "firecracker_rss_mb": 5686.2265625, + "fc_socket_count": 121, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 122, + "boot_time_s": 3.1, + "density_at_boot": 122, + "timestamp": 1773030519.3698952, + "vms_running": 122, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 8.528865814208984, + "host_disk_used_gb": 2.0466270446777344, + "tap_count": 122, + "firecracker_rss_mb": 5733.15625, + "fc_socket_count": 122, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 123, + "boot_time_s": 3.122, + "density_at_boot": 123, + "timestamp": 1773030522.651457, + "vms_running": 123, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.57718276977539, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 123, + "firecracker_rss_mb": 5779.828125, + "fc_socket_count": 123, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 124, + "boot_time_s": 3.197, + "density_at_boot": 124, + "timestamp": 1773030526.0088286, + "vms_running": 124, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.63067626953125, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 124, + "firecracker_rss_mb": 5826.75390625, + "fc_socket_count": 124, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 125, + "boot_time_s": 2.181, + "density_at_boot": 125, + "timestamp": 1773030528.3499966, + "vms_running": 125, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.678535461425781, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 125, + "firecracker_rss_mb": 5873.67578125, + "fc_socket_count": 125, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 126, + "boot_time_s": 3.1, + "density_at_boot": 126, + "timestamp": 1773030531.6112616, + "vms_running": 126, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 8.732891082763672, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 126, + "firecracker_rss_mb": 5920.60546875, + "fc_socket_count": 126, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 127, + "boot_time_s": 3.12, + "density_at_boot": 127, + "timestamp": 1773030534.8902926, + "vms_running": 127, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.7703857421875, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 127, + "firecracker_rss_mb": 5967.01953125, + "fc_socket_count": 127, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 128, + "boot_time_s": 3.118, + "density_at_boot": 128, + "timestamp": 1773030538.1708665, + "vms_running": 128, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.829139709472656, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 128, + "firecracker_rss_mb": 6014.20703125, + "fc_socket_count": 128, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 129, + "boot_time_s": 3.277, + "density_at_boot": 129, + "timestamp": 1773030541.6091838, + "vms_running": 129, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.878833770751953, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 129, + "firecracker_rss_mb": 6060.87890625, + "fc_socket_count": 129, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 130, + "boot_time_s": 3.119, + "density_at_boot": 130, + "timestamp": 1773030544.8907666, + "vms_running": 130, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.921592712402344, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 130, + "firecracker_rss_mb": 6108.0625, + "fc_socket_count": 130, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 131, + "boot_time_s": 2.18, + "density_at_boot": 131, + "timestamp": 1773030547.231964, + "vms_running": 131, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 8.96993637084961, + "host_disk_used_gb": 2.0505332946777344, + "tap_count": 131, + "firecracker_rss_mb": 6155.76171875, + "fc_socket_count": 131, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 132, + "boot_time_s": 3.097, + "density_at_boot": 132, + "timestamp": 1773030550.4896605, + "vms_running": 132, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.014835357666016, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 132, + "firecracker_rss_mb": 6203.20703125, + "fc_socket_count": 132, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 133, + "boot_time_s": 3.121, + "density_at_boot": 133, + "timestamp": 1773030553.7719686, + "vms_running": 133, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.057540893554688, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 133, + "firecracker_rss_mb": 6250.13671875, + "fc_socket_count": 133, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 134, + "boot_time_s": 3.116, + "density_at_boot": 134, + "timestamp": 1773030557.049676, + "vms_running": 134, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.09420394897461, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 134, + "firecracker_rss_mb": 6296.80859375, + "fc_socket_count": 134, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 135, + "boot_time_s": 3.119, + "density_at_boot": 135, + "timestamp": 1773030560.3302941, + "vms_running": 135, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 9.1478271484375, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 135, + "firecracker_rss_mb": 6343.21875, + "fc_socket_count": 135, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 136, + "boot_time_s": 3.28, + "density_at_boot": 136, + "timestamp": 1773030563.7712762, + "vms_running": 136, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.195480346679688, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 136, + "firecracker_rss_mb": 6390.1484375, + "fc_socket_count": 136, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 137, + "boot_time_s": 3.112, + "density_at_boot": 137, + "timestamp": 1773030567.0495977, + "vms_running": 137, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 9.255233764648438, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 137, + "firecracker_rss_mb": 6437.33203125, + "fc_socket_count": 137, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 138, + "boot_time_s": 3.12, + "density_at_boot": 138, + "timestamp": 1773030570.3295374, + "vms_running": 138, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.305980682373047, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 138, + "firecracker_rss_mb": 6484.515625, + "fc_socket_count": 138, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 139, + "boot_time_s": 3.117, + "density_at_boot": 139, + "timestamp": 1773030573.6100335, + "vms_running": 139, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.334781646728516, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 139, + "firecracker_rss_mb": 6531.43359375, + "fc_socket_count": 139, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 140, + "boot_time_s": 3.071, + "density_at_boot": 140, + "timestamp": 1773030576.8478024, + "vms_running": 140, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.384021759033203, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 140, + "firecracker_rss_mb": 6578.1015625, + "fc_socket_count": 140, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 141, + "boot_time_s": 2.175, + "density_at_boot": 141, + "timestamp": 1773030579.1875234, + "vms_running": 141, + "host_cpu_pct": 0.7, + "host_mem_used_gb": 9.426738739013672, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 141, + "firecracker_rss_mb": 6625.8046875, + "fc_socket_count": 141, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 142, + "boot_time_s": 3.145, + "density_at_boot": 142, + "timestamp": 1773030582.4925492, + "vms_running": 142, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.477222442626953, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 142, + "firecracker_rss_mb": 6672.4765625, + "fc_socket_count": 142, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 143, + "boot_time_s": 3.114, + "density_at_boot": 143, + "timestamp": 1773030585.7700963, + "vms_running": 143, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.525901794433594, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 143, + "firecracker_rss_mb": 6719.66015625, + "fc_socket_count": 143, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 144, + "boot_time_s": 3.117, + "density_at_boot": 144, + "timestamp": 1773030589.0509582, + "vms_running": 144, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.575244903564453, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 144, + "firecracker_rss_mb": 6766.328125, + "fc_socket_count": 144, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 145, + "boot_time_s": 3.115, + "density_at_boot": 145, + "timestamp": 1773030592.3305056, + "vms_running": 145, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.611865997314453, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 145, + "firecracker_rss_mb": 6814.02734375, + "fc_socket_count": 145, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 146, + "boot_time_s": 3.118, + "density_at_boot": 146, + "timestamp": 1773030595.6105, + "vms_running": 146, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.659114837646484, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 146, + "firecracker_rss_mb": 6860.6953125, + "fc_socket_count": 146, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 147, + "boot_time_s": 2.258, + "density_at_boot": 147, + "timestamp": 1773030598.0313594, + "vms_running": 147, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.711494445800781, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 147, + "firecracker_rss_mb": 6907.87890625, + "fc_socket_count": 147, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 148, + "boot_time_s": 2.237, + "density_at_boot": 148, + "timestamp": 1773030600.4328067, + "vms_running": 148, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.750930786132812, + "host_disk_used_gb": 2.0583457946777344, + "tap_count": 148, + "firecracker_rss_mb": 6954.55078125, + "fc_socket_count": 148, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 149, + "boot_time_s": 3.254, + "density_at_boot": 149, + "timestamp": 1773030603.8505654, + "vms_running": 149, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.808307647705078, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 149, + "firecracker_rss_mb": 7001.734375, + "fc_socket_count": 149, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 150, + "boot_time_s": 2.41, + "density_at_boot": 150, + "timestamp": 1773030606.4302688, + "vms_running": 150, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.865447998046875, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 150, + "firecracker_rss_mb": 7048.40234375, + "fc_socket_count": 150, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 151, + "boot_time_s": 3.09, + "density_at_boot": 151, + "timestamp": 1773030609.688327, + "vms_running": 151, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.906211853027344, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 151, + "firecracker_rss_mb": 7095.84375, + "fc_socket_count": 151, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 152, + "boot_time_s": 3.112, + "density_at_boot": 152, + "timestamp": 1773030612.9691172, + "vms_running": 152, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 9.950942993164062, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 152, + "firecracker_rss_mb": 7143.01953125, + "fc_socket_count": 152, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 153, + "boot_time_s": 3.114, + "density_at_boot": 153, + "timestamp": 1773030616.2511256, + "vms_running": 153, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.000373840332031, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 153, + "firecracker_rss_mb": 7189.9453125, + "fc_socket_count": 153, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 154, + "boot_time_s": 3.072, + "density_at_boot": 154, + "timestamp": 1773030619.4881804, + "vms_running": 154, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.039505004882812, + "host_disk_used_gb": 2.0583724975585938, + "tap_count": 154, + "firecracker_rss_mb": 7236.87109375, + "fc_socket_count": 154, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 155, + "boot_time_s": 3.155, + "density_at_boot": 155, + "timestamp": 1773030622.8121285, + "vms_running": 155, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.089401245117188, + "host_disk_used_gb": 2.0583724975585938, + "tap_count": 155, + "firecracker_rss_mb": 7283.28125, + "fc_socket_count": 155, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 156, + "boot_time_s": 3.109, + "density_at_boot": 156, + "timestamp": 1773030626.0889082, + "vms_running": 156, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.142635345458984, + "host_disk_used_gb": 2.0583724975585938, + "tap_count": 156, + "firecracker_rss_mb": 7330.98046875, + "fc_socket_count": 156, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 157, + "boot_time_s": 2.337, + "density_at_boot": 157, + "timestamp": 1773030628.5903733, + "vms_running": 157, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.189945220947266, + "host_disk_used_gb": 2.0583724975585938, + "tap_count": 157, + "firecracker_rss_mb": 7378.16796875, + "fc_socket_count": 157, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 158, + "boot_time_s": 3.094, + "density_at_boot": 158, + "timestamp": 1773030631.8515127, + "vms_running": 158, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.231304168701172, + "host_disk_used_gb": 2.0583724975585938, + "tap_count": 158, + "firecracker_rss_mb": 7424.58203125, + "fc_socket_count": 158, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 159, + "boot_time_s": 3.197, + "density_at_boot": 159, + "timestamp": 1773030635.2117321, + "vms_running": 159, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.280147552490234, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 159, + "firecracker_rss_mb": 7471.25, + "fc_socket_count": 159, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 160, + "boot_time_s": 3.107, + "density_at_boot": 160, + "timestamp": 1773030638.4903946, + "vms_running": 160, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.326778411865234, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 160, + "firecracker_rss_mb": 7517.91796875, + "fc_socket_count": 160, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 161, + "boot_time_s": 2.258, + "density_at_boot": 161, + "timestamp": 1773030640.9121716, + "vms_running": 161, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.386829376220703, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 161, + "firecracker_rss_mb": 7565.10546875, + "fc_socket_count": 161, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 162, + "boot_time_s": 3.167, + "density_at_boot": 162, + "timestamp": 1773030644.2489805, + "vms_running": 162, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.427810668945312, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 162, + "firecracker_rss_mb": 7612.8046875, + "fc_socket_count": 162, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 163, + "boot_time_s": 3.197, + "density_at_boot": 163, + "timestamp": 1773030647.610271, + "vms_running": 163, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.476997375488281, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 163, + "firecracker_rss_mb": 7659.21484375, + "fc_socket_count": 163, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 164, + "boot_time_s": 3.112, + "density_at_boot": 164, + "timestamp": 1773030650.890383, + "vms_running": 164, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.52157974243164, + "host_disk_used_gb": 2.0583953857421875, + "tap_count": 164, + "firecracker_rss_mb": 7706.39453125, + "fc_socket_count": 164, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 165, + "boot_time_s": 3.111, + "density_at_boot": 165, + "timestamp": 1773030654.1697454, + "vms_running": 165, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.563072204589844, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 165, + "firecracker_rss_mb": 7753.0625, + "fc_socket_count": 165, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 166, + "boot_time_s": 3.112, + "density_at_boot": 166, + "timestamp": 1773030657.4499469, + "vms_running": 166, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.615184783935547, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 166, + "firecracker_rss_mb": 7799.98828125, + "fc_socket_count": 166, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 167, + "boot_time_s": 3.109, + "density_at_boot": 167, + "timestamp": 1773030660.7303357, + "vms_running": 167, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.67031478881836, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 167, + "firecracker_rss_mb": 7846.91796875, + "fc_socket_count": 167, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 168, + "boot_time_s": 3.27, + "density_at_boot": 168, + "timestamp": 1773030664.1703522, + "vms_running": 168, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.707141876220703, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 168, + "firecracker_rss_mb": 7893.84765625, + "fc_socket_count": 168, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 169, + "boot_time_s": 3.19, + "density_at_boot": 169, + "timestamp": 1773030667.531072, + "vms_running": 169, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.751598358154297, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 169, + "firecracker_rss_mb": 7940.7734375, + "fc_socket_count": 169, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 170, + "boot_time_s": 3.193, + "density_at_boot": 170, + "timestamp": 1773030670.8925266, + "vms_running": 170, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.796680450439453, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 170, + "firecracker_rss_mb": 7987.69921875, + "fc_socket_count": 170, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 171, + "boot_time_s": 3.27, + "density_at_boot": 171, + "timestamp": 1773030674.331295, + "vms_running": 171, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.846931457519531, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 171, + "firecracker_rss_mb": 8035.140625, + "fc_socket_count": 171, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 172, + "boot_time_s": 3.108, + "density_at_boot": 172, + "timestamp": 1773030677.6099017, + "vms_running": 172, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.904075622558594, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 172, + "firecracker_rss_mb": 8081.8125, + "fc_socket_count": 172, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 173, + "boot_time_s": 3.113, + "density_at_boot": 173, + "timestamp": 1773030680.8904607, + "vms_running": 173, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.955322265625, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 173, + "firecracker_rss_mb": 8129.0, + "fc_socket_count": 173, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 174, + "boot_time_s": 3.108, + "density_at_boot": 174, + "timestamp": 1773030684.1715791, + "vms_running": 174, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.999347686767578, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 174, + "firecracker_rss_mb": 8175.671875, + "fc_socket_count": 174, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 175, + "boot_time_s": 2.159, + "density_at_boot": 175, + "timestamp": 1773030686.5001981, + "vms_running": 175, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.050048828125, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 175, + "firecracker_rss_mb": 8222.59765625, + "fc_socket_count": 175, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 176, + "boot_time_s": 2.245, + "density_at_boot": 176, + "timestamp": 1773030688.9127882, + "vms_running": 176, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.09844970703125, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 176, + "firecracker_rss_mb": 8269.78515625, + "fc_socket_count": 176, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 177, + "boot_time_s": 2.306, + "density_at_boot": 177, + "timestamp": 1773030691.3898923, + "vms_running": 177, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 11.14117431640625, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 177, + "firecracker_rss_mb": 8317.7421875, + "fc_socket_count": 177, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 178, + "boot_time_s": 2.394, + "density_at_boot": 178, + "timestamp": 1773030693.9516737, + "vms_running": 178, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.173641204833984, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 178, + "firecracker_rss_mb": 8364.67578125, + "fc_socket_count": 178, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 179, + "boot_time_s": 3.123, + "density_at_boot": 179, + "timestamp": 1773030697.2473683, + "vms_running": 179, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 11.224136352539062, + "host_disk_used_gb": 2.0583763122558594, + "tap_count": 179, + "firecracker_rss_mb": 8411.59765625, + "fc_socket_count": 179, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 180, + "boot_time_s": 3.112, + "density_at_boot": 180, + "timestamp": 1773030700.5280075, + "vms_running": 180, + "host_cpu_pct": 0.7, + "host_mem_used_gb": 11.270156860351562, + "host_disk_used_gb": 2.058399200439453, + "tap_count": 180, + "firecracker_rss_mb": 8458.265625, + "fc_socket_count": 180, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 181, + "boot_time_s": 3.107, + "density_at_boot": 181, + "timestamp": 1773030703.8073387, + "vms_running": 181, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 11.326152801513672, + "host_disk_used_gb": 2.058399200439453, + "tap_count": 181, + "firecracker_rss_mb": 8504.67578125, + "fc_socket_count": 181, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 182, + "boot_time_s": 3.155, + "density_at_boot": 182, + "timestamp": 1773030707.1316395, + "vms_running": 182, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.362808227539062, + "host_disk_used_gb": 2.058399200439453, + "tap_count": 182, + "firecracker_rss_mb": 8551.34375, + "fc_socket_count": 182, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 183, + "boot_time_s": 3.185, + "density_at_boot": 183, + "timestamp": 1773030710.4908752, + "vms_running": 183, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.415206909179688, + "host_disk_used_gb": 2.058399200439453, + "tap_count": 183, + "firecracker_rss_mb": 8597.75390625, + "fc_socket_count": 183, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 184, + "boot_time_s": 3.105, + "density_at_boot": 184, + "timestamp": 1773030713.7688148, + "vms_running": 184, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.45949935913086, + "host_disk_used_gb": 2.058399200439453, + "tap_count": 184, + "firecracker_rss_mb": 8644.42578125, + "fc_socket_count": 184, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 185, + "boot_time_s": 2.253, + "density_at_boot": 185, + "timestamp": 1773030716.1917515, + "vms_running": 185, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.509101867675781, + "host_disk_used_gb": 2.066211700439453, + "tap_count": 185, + "firecracker_rss_mb": 8691.09765625, + "fc_socket_count": 185, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 186, + "boot_time_s": 3.088, + "density_at_boot": 186, + "timestamp": 1773030719.4508097, + "vms_running": 186, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.55441665649414, + "host_disk_used_gb": 2.066211700439453, + "tap_count": 186, + "firecracker_rss_mb": 8738.0234375, + "fc_socket_count": 186, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 187, + "boot_time_s": 3.187, + "density_at_boot": 187, + "timestamp": 1773030722.8107624, + "vms_running": 187, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.595779418945312, + "host_disk_used_gb": 2.0662155151367188, + "tap_count": 187, + "firecracker_rss_mb": 8785.46875, + "fc_socket_count": 187, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 188, + "boot_time_s": 3.183, + "density_at_boot": 188, + "timestamp": 1773030726.1698601, + "vms_running": 188, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.638084411621094, + "host_disk_used_gb": 2.0662155151367188, + "tap_count": 188, + "firecracker_rss_mb": 8832.140625, + "fc_socket_count": 188, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 189, + "boot_time_s": 3.188, + "density_at_boot": 189, + "timestamp": 1773030729.5314174, + "vms_running": 189, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.685455322265625, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 189, + "firecracker_rss_mb": 8878.546875, + "fc_socket_count": 189, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 190, + "boot_time_s": 3.186, + "density_at_boot": 190, + "timestamp": 1773030732.8922422, + "vms_running": 190, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.731220245361328, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 190, + "firecracker_rss_mb": 8925.21875, + "fc_socket_count": 190, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 191, + "boot_time_s": 2.566, + "density_at_boot": 191, + "timestamp": 1773030735.6304379, + "vms_running": 191, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.782596588134766, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 191, + "firecracker_rss_mb": 8972.14453125, + "fc_socket_count": 191, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 192, + "boot_time_s": 3.119, + "density_at_boot": 192, + "timestamp": 1773030738.926491, + "vms_running": 192, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.833518981933594, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 192, + "firecracker_rss_mb": 9018.55859375, + "fc_socket_count": 192, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 193, + "boot_time_s": 3.237, + "density_at_boot": 193, + "timestamp": 1773030742.3309171, + "vms_running": 193, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.877479553222656, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 193, + "firecracker_rss_mb": 9065.2265625, + "fc_socket_count": 193, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 194, + "boot_time_s": 3.184, + "density_at_boot": 194, + "timestamp": 1773030745.690347, + "vms_running": 194, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.925689697265625, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 194, + "firecracker_rss_mb": 9111.63671875, + "fc_socket_count": 194, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 195, + "boot_time_s": 3.183, + "density_at_boot": 195, + "timestamp": 1773030749.0497975, + "vms_running": 195, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.97934341430664, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 195, + "firecracker_rss_mb": 9158.8203125, + "fc_socket_count": 195, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 196, + "boot_time_s": 3.186, + "density_at_boot": 196, + "timestamp": 1773030752.4114738, + "vms_running": 196, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.023429870605469, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 196, + "firecracker_rss_mb": 9206.265625, + "fc_socket_count": 196, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 197, + "boot_time_s": 3.187, + "density_at_boot": 197, + "timestamp": 1773030755.7730057, + "vms_running": 197, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.065494537353516, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 197, + "firecracker_rss_mb": 9253.19921875, + "fc_socket_count": 197, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 198, + "boot_time_s": 3.185, + "density_at_boot": 198, + "timestamp": 1773030759.1315176, + "vms_running": 198, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.100284576416016, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 198, + "firecracker_rss_mb": 9300.125, + "fc_socket_count": 198, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 199, + "boot_time_s": 3.186, + "density_at_boot": 199, + "timestamp": 1773030762.4906874, + "vms_running": 199, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 12.152381896972656, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 199, + "firecracker_rss_mb": 9346.79296875, + "fc_socket_count": 199, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 200, + "boot_time_s": 3.19, + "density_at_boot": 200, + "timestamp": 1773030765.8521874, + "vms_running": 200, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.194412231445312, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 200, + "firecracker_rss_mb": 9393.203125, + "fc_socket_count": 200, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 201, + "boot_time_s": 3.182, + "density_at_boot": 201, + "timestamp": 1773030769.2110555, + "vms_running": 201, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.248680114746094, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 201, + "firecracker_rss_mb": 9440.38671875, + "fc_socket_count": 201, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 202, + "boot_time_s": 3.187, + "density_at_boot": 202, + "timestamp": 1773030772.5721247, + "vms_running": 202, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.292709350585938, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 202, + "firecracker_rss_mb": 9487.31640625, + "fc_socket_count": 202, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 203, + "boot_time_s": 3.184, + "density_at_boot": 203, + "timestamp": 1773030775.9301012, + "vms_running": 203, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.340782165527344, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 203, + "firecracker_rss_mb": 9534.5, + "fc_socket_count": 203, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 204, + "boot_time_s": 3.186, + "density_at_boot": 204, + "timestamp": 1773030779.2917938, + "vms_running": 204, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.385353088378906, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 204, + "firecracker_rss_mb": 9581.42578125, + "fc_socket_count": 204, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 205, + "boot_time_s": 2.228, + "density_at_boot": 205, + "timestamp": 1773030781.699019, + "vms_running": 205, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.443012237548828, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 205, + "firecracker_rss_mb": 9628.09375, + "fc_socket_count": 205, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 206, + "boot_time_s": 3.258, + "density_at_boot": 206, + "timestamp": 1773030785.1319654, + "vms_running": 206, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.488906860351562, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 206, + "firecracker_rss_mb": 9674.765625, + "fc_socket_count": 206, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 207, + "boot_time_s": 3.183, + "density_at_boot": 207, + "timestamp": 1773030788.4889982, + "vms_running": 207, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.53817367553711, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 207, + "firecracker_rss_mb": 9720.91796875, + "fc_socket_count": 207, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 208, + "boot_time_s": 3.182, + "density_at_boot": 208, + "timestamp": 1773030791.851776, + "vms_running": 208, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.58414077758789, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 208, + "firecracker_rss_mb": 9767.58984375, + "fc_socket_count": 208, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 209, + "boot_time_s": 3.262, + "density_at_boot": 209, + "timestamp": 1773030795.2908702, + "vms_running": 209, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.634292602539062, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 209, + "firecracker_rss_mb": 9814.515625, + "fc_socket_count": 209, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 210, + "boot_time_s": 3.185, + "density_at_boot": 210, + "timestamp": 1773030798.651638, + "vms_running": 210, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.678108215332031, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 210, + "firecracker_rss_mb": 9861.44140625, + "fc_socket_count": 210, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 211, + "boot_time_s": 3.345, + "density_at_boot": 211, + "timestamp": 1773030802.1711235, + "vms_running": 211, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 12.741558074951172, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 211, + "firecracker_rss_mb": 9908.37109375, + "fc_socket_count": 211, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 212, + "boot_time_s": 2.33, + "density_at_boot": 212, + "timestamp": 1773030804.678945, + "vms_running": 212, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.78213119506836, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 212, + "firecracker_rss_mb": 9955.55078125, + "fc_socket_count": 212, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 213, + "boot_time_s": 3.317, + "density_at_boot": 213, + "timestamp": 1773030808.1695566, + "vms_running": 213, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.833099365234375, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 213, + "firecracker_rss_mb": 10002.4765625, + "fc_socket_count": 213, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 214, + "boot_time_s": 3.182, + "density_at_boot": 214, + "timestamp": 1773030811.5305533, + "vms_running": 214, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.866477966308594, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 214, + "firecracker_rss_mb": 10048.890625, + "fc_socket_count": 214, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 215, + "boot_time_s": 3.182, + "density_at_boot": 215, + "timestamp": 1773030814.8910744, + "vms_running": 215, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 12.90692138671875, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 215, + "firecracker_rss_mb": 10095.55859375, + "fc_socket_count": 215, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 216, + "boot_time_s": 3.262, + "density_at_boot": 216, + "timestamp": 1773030818.331957, + "vms_running": 216, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.956188201904297, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 216, + "firecracker_rss_mb": 10142.2265625, + "fc_socket_count": 216, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 217, + "boot_time_s": 3.177, + "density_at_boot": 217, + "timestamp": 1773030821.6885786, + "vms_running": 217, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.005245208740234, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 217, + "firecracker_rss_mb": 10189.15625, + "fc_socket_count": 217, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 218, + "boot_time_s": 3.192, + "density_at_boot": 218, + "timestamp": 1773030825.0542357, + "vms_running": 218, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.052791595458984, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 218, + "firecracker_rss_mb": 10235.5703125, + "fc_socket_count": 218, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 219, + "boot_time_s": 2.186, + "density_at_boot": 219, + "timestamp": 1773030827.4184048, + "vms_running": 219, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.102787017822266, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 219, + "firecracker_rss_mb": 10282.7578125, + "fc_socket_count": 219, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 220, + "boot_time_s": 3.22, + "density_at_boot": 220, + "timestamp": 1773030830.8120756, + "vms_running": 220, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.151496887207031, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 220, + "firecracker_rss_mb": 10329.9453125, + "fc_socket_count": 220, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 221, + "boot_time_s": 3.259, + "density_at_boot": 221, + "timestamp": 1773030834.2496157, + "vms_running": 221, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.200881958007812, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 221, + "firecracker_rss_mb": 10377.12890625, + "fc_socket_count": 221, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 222, + "boot_time_s": 3.138, + "density_at_boot": 222, + "timestamp": 1773030837.5682049, + "vms_running": 222, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.251548767089844, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 222, + "firecracker_rss_mb": 10423.5390625, + "fc_socket_count": 222, + "sqlite_db_kb": 280.0 + }, + { + "event": "boot_ok", + "vm_seq": 223, + "boot_time_s": 3.224, + "density_at_boot": 223, + "timestamp": 1773030840.9711266, + "vms_running": 223, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.295562744140625, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 223, + "firecracker_rss_mb": 10470.20703125, + "fc_socket_count": 223, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 224, + "boot_time_s": 3.177, + "density_at_boot": 224, + "timestamp": 1773030844.3304691, + "vms_running": 224, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.34567642211914, + "host_disk_used_gb": 2.0661964416503906, + "tap_count": 224, + "firecracker_rss_mb": 10517.13671875, + "fc_socket_count": 224, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 225, + "boot_time_s": 2.279, + "density_at_boot": 225, + "timestamp": 1773030846.7891102, + "vms_running": 225, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.394973754882812, + "host_disk_used_gb": 2.0662193298339844, + "tap_count": 225, + "firecracker_rss_mb": 10564.06640625, + "fc_socket_count": 225, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 226, + "boot_time_s": 3.206, + "density_at_boot": 226, + "timestamp": 1773030850.1729743, + "vms_running": 226, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.445087432861328, + "host_disk_used_gb": 2.0662193298339844, + "tap_count": 226, + "firecracker_rss_mb": 10610.9921875, + "fc_socket_count": 226, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 227, + "boot_time_s": 3.255, + "density_at_boot": 227, + "timestamp": 1773030853.609889, + "vms_running": 227, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.492591857910156, + "host_disk_used_gb": 2.0662193298339844, + "tap_count": 227, + "firecracker_rss_mb": 10657.91796875, + "fc_socket_count": 227, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 228, + "boot_time_s": 3.217, + "density_at_boot": 228, + "timestamp": 1773030857.0059326, + "vms_running": 228, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 13.540851593017578, + "host_disk_used_gb": 2.0662193298339844, + "tap_count": 228, + "firecracker_rss_mb": 10704.84765625, + "fc_socket_count": 228, + "sqlite_db_kb": 284.0 + }, + { + "event": "boot_ok", + "vm_seq": 229, + "boot_time_s": 3.232, + "density_at_boot": 229, + "timestamp": 1773030860.4121194, + "vms_running": 229, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.580379486083984, + "host_disk_used_gb": 2.0662002563476562, + "tap_count": 229, + "firecracker_rss_mb": 10751.77734375, + "fc_socket_count": 229, + "sqlite_db_kb": 288.0 + }, + { + "event": "boot_ok", + "vm_seq": 230, + "boot_time_s": 2.274, + "density_at_boot": 230, + "timestamp": 1773030862.8678098, + "vms_running": 230, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 13.631404876708984, + "host_disk_used_gb": 2.0662002563476562, + "tap_count": 230, + "firecracker_rss_mb": 10799.4765625, + "fc_socket_count": 230, + "sqlite_db_kb": 288.0 + }, + { + "event": "boot_ok", + "vm_seq": 231, + "boot_time_s": 3.333, + "density_at_boot": 231, + "timestamp": 1773030866.3781908, + "vms_running": 231, + "host_cpu_pct": 0.8, + "host_mem_used_gb": 13.685527801513672, + "host_disk_used_gb": 2.0662002563476562, + "tap_count": 231, + "firecracker_rss_mb": 10846.66015625, + "fc_socket_count": 231, + "sqlite_db_kb": 288.0 + }, + { + "event": "boot_ok", + "vm_seq": 232, + "boot_time_s": 3.287, + "density_at_boot": 232, + "timestamp": 1773030869.849167, + "vms_running": 232, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.733783721923828, + "host_disk_used_gb": 2.0662002563476562, + "tap_count": 232, + "firecracker_rss_mb": 10893.5859375, + "fc_socket_count": 232, + "sqlite_db_kb": 288.0 + }, + { + "event": "boot_ok", + "vm_seq": 233, + "boot_time_s": 3.192, + "density_at_boot": 233, + "timestamp": 1773030873.2213478, + "vms_running": 233, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.771747589111328, + "host_disk_used_gb": 2.0740127563476562, + "tap_count": 233, + "firecracker_rss_mb": 10940.51953125, + "fc_socket_count": 233, + "sqlite_db_kb": 288.0 + }, + { + "event": "boot_ok", + "vm_seq": 234, + "boot_time_s": 3.244, + "density_at_boot": 234, + "timestamp": 1773030876.6512637, + "vms_running": 234, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.816898345947266, + "host_disk_used_gb": 2.0740127563476562, + "tap_count": 234, + "firecracker_rss_mb": 10987.96484375, + "fc_socket_count": 234, + "sqlite_db_kb": 292.0 + }, + { + "event": "boot_ok", + "vm_seq": 235, + "boot_time_s": 3.18, + "density_at_boot": 235, + "timestamp": 1773030880.011383, + "vms_running": 235, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.860759735107422, + "host_disk_used_gb": 2.07403564453125, + "tap_count": 235, + "firecracker_rss_mb": 11034.62890625, + "fc_socket_count": 235, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 236, + "boot_time_s": 3.335, + "density_at_boot": 236, + "timestamp": 1773030883.5314436, + "vms_running": 236, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.902542114257812, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 236, + "firecracker_rss_mb": 11081.55859375, + "fc_socket_count": 236, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 237, + "boot_time_s": 2.319, + "density_at_boot": 237, + "timestamp": 1773030886.0321264, + "vms_running": 237, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.950122833251953, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 237, + "firecracker_rss_mb": 11128.48828125, + "fc_socket_count": 237, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 238, + "boot_time_s": 3.318, + "density_at_boot": 238, + "timestamp": 1773030889.532275, + "vms_running": 238, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.003963470458984, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 238, + "firecracker_rss_mb": 11175.16015625, + "fc_socket_count": 238, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 239, + "boot_time_s": 3.254, + "density_at_boot": 239, + "timestamp": 1773030892.9688118, + "vms_running": 239, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.04220962524414, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 239, + "firecracker_rss_mb": 11222.0859375, + "fc_socket_count": 239, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 240, + "boot_time_s": 3.259, + "density_at_boot": 240, + "timestamp": 1773030896.410509, + "vms_running": 240, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 14.089305877685547, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 240, + "firecracker_rss_mb": 11268.7578125, + "fc_socket_count": 240, + "sqlite_db_kb": 296.0 + }, + { + "event": "boot_ok", + "vm_seq": 241, + "boot_time_s": 2.32, + "density_at_boot": 241, + "timestamp": 1773030898.912195, + "vms_running": 241, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.13222885131836, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 241, + "firecracker_rss_mb": 11315.68359375, + "fc_socket_count": 241, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 242, + "boot_time_s": 3.16, + "density_at_boot": 242, + "timestamp": 1773030902.252483, + "vms_running": 242, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.179145812988281, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 242, + "firecracker_rss_mb": 11362.3515625, + "fc_socket_count": 242, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 243, + "boot_time_s": 3.177, + "density_at_boot": 243, + "timestamp": 1773030905.6109297, + "vms_running": 243, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.226566314697266, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 243, + "firecracker_rss_mb": 11409.53125, + "fc_socket_count": 243, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 244, + "boot_time_s": 3.176, + "density_at_boot": 244, + "timestamp": 1773030908.969251, + "vms_running": 244, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.275192260742188, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 244, + "firecracker_rss_mb": 11456.19921875, + "fc_socket_count": 244, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 245, + "boot_time_s": 2.396, + "density_at_boot": 245, + "timestamp": 1773030911.5503266, + "vms_running": 245, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.319305419921875, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 245, + "firecracker_rss_mb": 11503.12890625, + "fc_socket_count": 245, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 246, + "boot_time_s": 3.239, + "density_at_boot": 246, + "timestamp": 1773030914.9717393, + "vms_running": 246, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.369342803955078, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 246, + "firecracker_rss_mb": 11549.5390625, + "fc_socket_count": 246, + "sqlite_db_kb": 300.0 + }, + { + "event": "boot_ok", + "vm_seq": 247, + "boot_time_s": 3.256, + "density_at_boot": 247, + "timestamp": 1773030918.4093506, + "vms_running": 247, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.412841796875, + "host_disk_used_gb": 2.074016571044922, + "tap_count": 247, + "firecracker_rss_mb": 11596.46875, + "fc_socket_count": 247, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 248, + "boot_time_s": 3.257, + "density_at_boot": 248, + "timestamp": 1773030921.849107, + "vms_running": 248, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.468254089355469, + "host_disk_used_gb": 2.0740699768066406, + "tap_count": 248, + "firecracker_rss_mb": 11643.39453125, + "fc_socket_count": 248, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 249, + "boot_time_s": 2.335, + "density_at_boot": 249, + "timestamp": 1773030924.3612962, + "vms_running": 249, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.515098571777344, + "host_disk_used_gb": 2.0740814208984375, + "tap_count": 249, + "firecracker_rss_mb": 11690.06640625, + "fc_socket_count": 249, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 250, + "boot_time_s": 3.342, + "density_at_boot": 250, + "timestamp": 1773030927.8892078, + "vms_running": 250, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.576744079589844, + "host_disk_used_gb": 2.0741424560546875, + "tap_count": 250, + "firecracker_rss_mb": 11737.24609375, + "fc_socket_count": 250, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 251, + "boot_time_s": 3.222, + "density_at_boot": 251, + "timestamp": 1773030931.2900705, + "vms_running": 251, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.61867904663086, + "host_disk_used_gb": 2.0741424560546875, + "tap_count": 251, + "firecracker_rss_mb": 11783.65625, + "fc_socket_count": 251, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 252, + "boot_time_s": 3.333, + "density_at_boot": 252, + "timestamp": 1773030934.8102415, + "vms_running": 252, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.672557830810547, + "host_disk_used_gb": 2.0742034912109375, + "tap_count": 252, + "firecracker_rss_mb": 11830.5859375, + "fc_socket_count": 252, + "sqlite_db_kb": 304.0 + }, + { + "event": "boot_ok", + "vm_seq": 253, + "boot_time_s": 3.253, + "density_at_boot": 253, + "timestamp": 1773030938.2493396, + "vms_running": 253, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.717056274414062, + "host_disk_used_gb": 2.0742034912109375, + "tap_count": 253, + "firecracker_rss_mb": 11877.26171875, + "fc_socket_count": 253, + "sqlite_db_kb": 308.0 + }, + { + "event": "sustain_check", + "sustain_sec": 60, + "vms_alive": 253, + "vms_dead": [], + "vms_checked": 253, + "timestamp": 1773030998.823995, + "vms_running": 253, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.539192199707031, + "host_disk_used_gb": 2.074188232421875, + "tap_count": 253, + "firecracker_rss_mb": 11949.96484375, + "fc_socket_count": 253, + "sqlite_db_kb": 308.0 + }, + { + "event": "teardown", + "teardown_time_s": 127.57, + "timestamp": 1773031126.5712855, + "vms_running": 0, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0837554931640625, + "host_disk_used_gb": 2.0742149353027344, + "tap_count": 253, + "firecracker_rss_mb": 0.0, + "fc_socket_count": 0, + "sqlite_db_kb": 308.0 + } +] \ No newline at end of file From 275fbfe4eb3c577088c0e29bcdf8441a889b7448 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 00:55:35 -0400 Subject: [PATCH 10/20] results README --- benchmarks/results/README.md | 190 +++++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 benchmarks/results/README.md diff --git a/benchmarks/results/README.md b/benchmarks/results/README.md new file mode 100644 index 0000000..340d38c --- /dev/null +++ b/benchmarks/results/README.md @@ -0,0 +1,190 @@ +# Density Ramp Results + +This directory contains JSON output files from `density_ramp.py` benchmark runs. Files are named `density_YYYYMMDD_HHMMSS.json` and timestamped at the start of the run. + +## File Structure + +Each file is a JSON array of event objects written sequentially during the run. Records appear in chronological order: one `boot_ok` or `boot_fail` per VM launch attempt, followed by a single `sustain_check`, and finally a `teardown` record. + +### Event Types + +#### `boot_ok` — successful VM boot + +```json +{ + "event": "boot_ok", + "vm_seq": 42, + "boot_time_s": 2.961, + "density_at_boot": 42, + "timestamp": 1773030151.45, + "vms_running": 42, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.82, + "host_disk_used_gb": 2.05, + "tap_count": 42, + "firecracker_rss_mb": 1968.5, + "fc_socket_count": 42, + "sqlite_db_kb": 120.0 +} +``` + +| Field | Description | +| ----- | ----------- | +| `vm_seq` | Sequential index of this VM (1-based launch order) | +| `boot_time_s` | Seconds from VM creation to SSH readiness — the true end-to-end "ready to serve" latency | +| `density_at_boot` | Number of concurrently running VMs at the moment this VM became ready (equals `vms_running` for sequential runs) | +| `timestamp` | Unix epoch at the moment boot was confirmed | +| `vms_running` | Total VMs alive on the host when metrics were sampled | +| `host_cpu_pct` | Host CPU utilization (%) at time of sampling | +| `host_mem_used_gb` | Host physical memory in use (GB) — includes OS, SmolVM process, and all Firecracker processes | +| `host_disk_used_gb` | Disk space consumed under the SmolVM data directory (GB) — grows with each per-VM rootfs clone in isolated mode | +| `tap_count` | Number of active tap network interfaces — should equal `vms_running` | +| `firecracker_rss_mb` | Aggregate RSS (resident set size) of all Firecracker processes (MB) | +| `fc_socket_count` | Number of Firecracker API sockets present — should equal `vms_running` | +| `sqlite_db_kb` | Size of the SmolVM SQLite state database (KB) — grows as VM records accumulate | + +#### `boot_fail` — VM failed to boot or reach SSH + +```json +{ + "event": "boot_fail", + "vm_seq": 254, + "error": "SSH did not become ready within 30s", + "timestamp": 1773031000.0, + "vms_running": 253, + "host_cpu_pct": 95.0, + "host_mem_used_gb": 191.5, + ... +} +``` + +Same host-metrics fields as `boot_ok` plus `error` (string describing the failure). The ramp stops after the first failure. + +#### `sustain_check` — liveness check after peak density + +```json +{ + "event": "sustain_check", + "sustain_sec": 60, + "vms_alive": 253, + "vms_dead": [], + "vms_checked": 253, + "timestamp": 1773030998.82, + "vms_running": 253, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.54, + "host_disk_used_gb": 2.07, + "tap_count": 253, + "firecracker_rss_mb": 11949.96, + "fc_socket_count": 253, + "sqlite_db_kb": 308.0 +} +``` + +| Field | Description | +| ----- | ----------- | +| `sustain_sec` | Seconds the benchmark idled at peak density before running this check | +| `vms_alive` | VMs that responded to the liveness command (`uptime`) | +| `vms_dead` | List of VM identifiers that failed the liveness check | +| `vms_checked` | Total VMs checked | + +Host metrics fields are the same as `boot_ok` and reflect system state at the time of the check — useful for spotting memory growth or CPU drift after a long soak. + +#### `teardown` — post-cleanup snapshot + +```json +{ + "event": "teardown", + "teardown_time_s": 127.57, + "timestamp": 1773031126.57, + "vms_running": 0, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.08, + "host_disk_used_gb": 2.07, + "tap_count": 253, + "firecracker_rss_mb": 0.0, + "fc_socket_count": 0, + "sqlite_db_kb": 308.0 +} +``` + +| Field | Description | +| ----- | ----------- | +| `teardown_time_s` | Seconds to stop all VMs gracefully | +| `host_disk_used_gb` | Disk after cleanup — delta vs. peak verifies per-VM rootfs clones were released | +| `tap_count` | Note: tap interfaces may linger after teardown until the OS reclaims them | +| `firecracker_rss_mb` | Should be 0.0 — confirms all Firecracker processes exited | + +--- + +## How to Interpret Results + +### Did the benchmark succeed? + +A successful run reaches `--max-attempts` VMs without any `boot_fail`, and the `sustain_check` shows `vms_alive == vms_checked`. A failed run ends with a `boot_fail` record; the `error` field and surrounding host metrics indicate the limiting resource. + +### What was the peak capacity? + +Count `boot_ok` records, or read `vms_running` from the `sustain_check`. + +### What was the per-VM memory cost? + +Compare `host_mem_used_gb` between early and late `boot_ok` records: + +```python +per_vm_mem_mb = (boots[-1]["host_mem_used_gb"] - boots[0]["host_mem_used_gb"]) \ + / (len(boots) - 1) * 1024 +``` + +For tiny VMs (128 MiB configured), expect roughly 48–55 MB actual RSS — Firecracker's overhead is well below the guest's configured memory. + +### What was the Firecracker process overhead per VM? + +```python +rss_per_vm_mb = boots[-1]["firecracker_rss_mb"] / len(boots) +``` + +This is the average RSS of a single Firecracker process. It should be roughly constant across density levels on a healthy run. + +### Was boot time stable under load? + +Plot `boot_time_s` against `vm_seq`. A flat line means boot latency doesn't degrade with density. An upward trend indicates CPU or I/O contention affecting startup. + +### What did teardown cost? + +`teardown_time_s` divided by `vms_checked` gives average stop-time per VM. Check that `host_disk_used_gb` in the teardown record is close to the value in the first `boot_ok` — a large residual indicates rootfs clones were not fully cleaned up. + +--- + +## Quick Analysis Script + +```python +import json + +with open("density_20260309_001743.json") as f: + data = json.load(f) + +boots = [d for d in data if d["event"] == "boot_ok"] +fails = [d for d in data if d["event"] == "boot_fail"] +sustain = next((d for d in data if d["event"] == "sustain_check"), None) +teardown = next((d for d in data if d["event"] == "teardown"), None) + +times = [d["boot_time_s"] for d in boots] +print(f"Peak VMs : {len(boots)}") +print(f"Failed boots : {len(fails)}") +print(f"Avg boot time : {sum(times)/len(times):.2f}s") +print(f"Max boot time : {max(times):.2f}s") +print(f"Peak mem used : {boots[-1]['host_mem_used_gb']:.2f} GB") +print(f"RSS per VM : {boots[-1]['firecracker_rss_mb'] / len(boots):.1f} MB") +if sustain: + print(f"Sustain result : {sustain['vms_alive']}/{sustain['vms_checked']} alive") +if teardown: + print(f"Teardown time : {teardown['teardown_time_s']:.1f}s") + print(f"Disk after : {teardown['host_disk_used_gb']:.3f} GB") +``` + +--- + +## File Naming + +Files generated by `run_density_ramp_ec2.sh` are named `density_YYYYMMDD_HHMMSS.json` where the timestamp is the local time on the machine that launched the EC2 script (not the EC2 instance). Files generated by running `density_ramp.py` directly use whatever `--output` argument was passed (default: `density.json`). From 2abbe7ecd13d1207c365cee18d43936d8ecb3d53 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 01:40:02 -0400 Subject: [PATCH 11/20] added second test after rebasing to upstream --- .../results/density_20260309_010721.json | 3826 +++++++++++++++++ 1 file changed, 3826 insertions(+) create mode 100644 benchmarks/results/density_20260309_010721.json diff --git a/benchmarks/results/density_20260309_010721.json b/benchmarks/results/density_20260309_010721.json new file mode 100644 index 0000000..8d948cf --- /dev/null +++ b/benchmarks/results/density_20260309_010721.json @@ -0,0 +1,3826 @@ +[ + { + "event": "boot_ok", + "vm_seq": 1, + "boot_time_s": 3.557, + "density_at_boot": 1, + "timestamp": 1773033027.8439739, + "vms_running": 1, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.7269515991210938, + "host_disk_used_gb": 2.0351943969726562, + "tap_count": 1, + "firecracker_rss_mb": 47.4375, + "fc_socket_count": 1, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 2, + "boot_time_s": 3.012, + "density_at_boot": 2, + "timestamp": 1773033031.0415125, + "vms_running": 2, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 2.7830047607421875, + "host_disk_used_gb": 2.0351943969726562, + "tap_count": 2, + "firecracker_rss_mb": 94.62109375, + "fc_socket_count": 2, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 3, + "boot_time_s": 2.976, + "density_at_boot": 3, + "timestamp": 1773033034.1608803, + "vms_running": 3, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 2.8303489685058594, + "host_disk_used_gb": 2.0352554321289062, + "tap_count": 3, + "firecracker_rss_mb": 141.55078125, + "fc_socket_count": 3, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 4, + "boot_time_s": 3.058, + "density_at_boot": 4, + "timestamp": 1773033037.361834, + "vms_running": 4, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.877735137939453, + "host_disk_used_gb": 2.0352554321289062, + "tap_count": 4, + "firecracker_rss_mb": 188.73828125, + "fc_socket_count": 4, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 5, + "boot_time_s": 3.218, + "density_at_boot": 5, + "timestamp": 1773033040.722996, + "vms_running": 5, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.936298370361328, + "host_disk_used_gb": 2.0353164672851562, + "tap_count": 5, + "firecracker_rss_mb": 235.14453125, + "fc_socket_count": 5, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 6, + "boot_time_s": 2.977, + "density_at_boot": 6, + "timestamp": 1773033043.8448167, + "vms_running": 6, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.993610382080078, + "host_disk_used_gb": 2.0353164672851562, + "tap_count": 6, + "firecracker_rss_mb": 282.84765625, + "fc_socket_count": 6, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 7, + "boot_time_s": 2.973, + "density_at_boot": 7, + "timestamp": 1773033046.962404, + "vms_running": 7, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0497703552246094, + "host_disk_used_gb": 2.0353775024414062, + "tap_count": 7, + "firecracker_rss_mb": 330.29296875, + "fc_socket_count": 7, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 8, + "boot_time_s": 2.117, + "density_at_boot": 8, + "timestamp": 1773033049.2229445, + "vms_running": 8, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.100330352783203, + "host_disk_used_gb": 2.0353775024414062, + "tap_count": 8, + "firecracker_rss_mb": 377.22265625, + "fc_socket_count": 8, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 9, + "boot_time_s": 3.035, + "density_at_boot": 9, + "timestamp": 1773033052.4030461, + "vms_running": 9, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.1607666015625, + "host_disk_used_gb": 2.0354385375976562, + "tap_count": 9, + "firecracker_rss_mb": 424.40625, + "fc_socket_count": 9, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 10, + "boot_time_s": 3.054, + "density_at_boot": 10, + "timestamp": 1773033055.6033888, + "vms_running": 10, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.2168922424316406, + "host_disk_used_gb": 2.0354385375976562, + "tap_count": 10, + "firecracker_rss_mb": 470.81640625, + "fc_socket_count": 10, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 11, + "boot_time_s": 2.973, + "density_at_boot": 11, + "timestamp": 1773033058.7229776, + "vms_running": 11, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.2730178833007812, + "host_disk_used_gb": 2.0354995727539062, + "tap_count": 11, + "firecracker_rss_mb": 517.48046875, + "fc_socket_count": 11, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 12, + "boot_time_s": 2.97, + "density_at_boot": 12, + "timestamp": 1773033061.8406522, + "vms_running": 12, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.3240890502929688, + "host_disk_used_gb": 2.0354995727539062, + "tap_count": 12, + "firecracker_rss_mb": 564.671875, + "fc_socket_count": 12, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 13, + "boot_time_s": 2.975, + "density_at_boot": 13, + "timestamp": 1773033064.9625804, + "vms_running": 13, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.38525390625, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 13, + "firecracker_rss_mb": 612.37109375, + "fc_socket_count": 13, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 14, + "boot_time_s": 2.053, + "density_at_boot": 14, + "timestamp": 1773033067.1609247, + "vms_running": 14, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.4327239990234375, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 14, + "firecracker_rss_mb": 660.078125, + "fc_socket_count": 14, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 15, + "boot_time_s": 2.075, + "density_at_boot": 15, + "timestamp": 1773033069.3810976, + "vms_running": 15, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.485340118408203, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 15, + "firecracker_rss_mb": 707.0, + "fc_socket_count": 15, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 16, + "boot_time_s": 1.971, + "density_at_boot": 16, + "timestamp": 1773033071.4986103, + "vms_running": 16, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.5328598022460938, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 16, + "firecracker_rss_mb": 754.95703125, + "fc_socket_count": 16, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 17, + "boot_time_s": 2.139, + "density_at_boot": 17, + "timestamp": 1773033073.7816103, + "vms_running": 17, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.590251922607422, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 17, + "firecracker_rss_mb": 801.8828125, + "fc_socket_count": 17, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 18, + "boot_time_s": 2.993, + "density_at_boot": 18, + "timestamp": 1773033076.9206767, + "vms_running": 18, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.6424293518066406, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 18, + "firecracker_rss_mb": 848.80859375, + "fc_socket_count": 18, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 19, + "boot_time_s": 3.095, + "density_at_boot": 19, + "timestamp": 1773033080.1619146, + "vms_running": 19, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.6910667419433594, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 19, + "firecracker_rss_mb": 895.73828125, + "fc_socket_count": 19, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 20, + "boot_time_s": 2.93, + "density_at_boot": 20, + "timestamp": 1773033083.2386947, + "vms_running": 20, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 3.746997833251953, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 20, + "firecracker_rss_mb": 943.69921875, + "fc_socket_count": 20, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 21, + "boot_time_s": 2.239, + "density_at_boot": 21, + "timestamp": 1773033085.62172, + "vms_running": 21, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.7973709106445312, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 21, + "firecracker_rss_mb": 990.62890625, + "fc_socket_count": 21, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 22, + "boot_time_s": 3.034, + "density_at_boot": 22, + "timestamp": 1773033088.8028262, + "vms_running": 22, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 3.8506126403808594, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 22, + "firecracker_rss_mb": 1037.55078125, + "fc_socket_count": 22, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 23, + "boot_time_s": 2.17, + "density_at_boot": 23, + "timestamp": 1773033091.1226404, + "vms_running": 23, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.9020309448242188, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 23, + "firecracker_rss_mb": 1084.47265625, + "fc_socket_count": 23, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 24, + "boot_time_s": 3.054, + "density_at_boot": 24, + "timestamp": 1773033094.3238337, + "vms_running": 24, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.951507568359375, + "host_disk_used_gb": 2.0360107421875, + "tap_count": 24, + "firecracker_rss_mb": 1131.40234375, + "fc_socket_count": 24, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 25, + "boot_time_s": 3.051, + "density_at_boot": 25, + "timestamp": 1773033097.5225387, + "vms_running": 25, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.002567291259766, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 25, + "firecracker_rss_mb": 1178.328125, + "fc_socket_count": 25, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 26, + "boot_time_s": 2.231, + "density_at_boot": 26, + "timestamp": 1773033099.9013627, + "vms_running": 26, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.061363220214844, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 26, + "firecracker_rss_mb": 1225.76953125, + "fc_socket_count": 26, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 27, + "boot_time_s": 3.073, + "density_at_boot": 27, + "timestamp": 1773033103.1235607, + "vms_running": 27, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.113433837890625, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 27, + "firecracker_rss_mb": 1272.69921875, + "fc_socket_count": 27, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 28, + "boot_time_s": 3.128, + "density_at_boot": 28, + "timestamp": 1773033106.4006462, + "vms_running": 28, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.165180206298828, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 28, + "firecracker_rss_mb": 1319.3671875, + "fc_socket_count": 28, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 29, + "boot_time_s": 3.056, + "density_at_boot": 29, + "timestamp": 1773033109.6045015, + "vms_running": 29, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.213230133056641, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 29, + "firecracker_rss_mb": 1366.80859375, + "fc_socket_count": 29, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 30, + "boot_time_s": 3.051, + "density_at_boot": 30, + "timestamp": 1773033112.804648, + "vms_running": 30, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.257366180419922, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 30, + "firecracker_rss_mb": 1413.48046875, + "fc_socket_count": 30, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 31, + "boot_time_s": 3.05, + "density_at_boot": 31, + "timestamp": 1773033116.0029683, + "vms_running": 31, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.305568695068359, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 31, + "firecracker_rss_mb": 1460.40234375, + "fc_socket_count": 31, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 32, + "boot_time_s": 3.052, + "density_at_boot": 32, + "timestamp": 1773033119.2038808, + "vms_running": 32, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 4.353710174560547, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 32, + "firecracker_rss_mb": 1507.328125, + "fc_socket_count": 32, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 33, + "boot_time_s": 3.13, + "density_at_boot": 33, + "timestamp": 1773033122.4816763, + "vms_running": 33, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.400493621826172, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 33, + "firecracker_rss_mb": 1554.2578125, + "fc_socket_count": 33, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 34, + "boot_time_s": 3.006, + "density_at_boot": 34, + "timestamp": 1773033125.6367514, + "vms_running": 34, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 4.442150115966797, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 34, + "firecracker_rss_mb": 1601.703125, + "fc_socket_count": 34, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 35, + "boot_time_s": 3.019, + "density_at_boot": 35, + "timestamp": 1773033128.801706, + "vms_running": 35, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.484050750732422, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 35, + "firecracker_rss_mb": 1648.6328125, + "fc_socket_count": 35, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 36, + "boot_time_s": 3.05, + "density_at_boot": 36, + "timestamp": 1773033132.0019503, + "vms_running": 36, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.5365753173828125, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 36, + "firecracker_rss_mb": 1695.5625, + "fc_socket_count": 36, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 37, + "boot_time_s": 3.048, + "density_at_boot": 37, + "timestamp": 1773033135.201699, + "vms_running": 37, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.581813812255859, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 37, + "firecracker_rss_mb": 1742.7421875, + "fc_socket_count": 37, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 38, + "boot_time_s": 3.051, + "density_at_boot": 38, + "timestamp": 1773033138.4028268, + "vms_running": 38, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.623851776123047, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 38, + "firecracker_rss_mb": 1789.671875, + "fc_socket_count": 38, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 39, + "boot_time_s": 3.051, + "density_at_boot": 39, + "timestamp": 1773033141.6038764, + "vms_running": 39, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.667224884033203, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 39, + "firecracker_rss_mb": 1836.34375, + "fc_socket_count": 39, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 40, + "boot_time_s": 3.047, + "density_at_boot": 40, + "timestamp": 1773033144.8007727, + "vms_running": 40, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.7087860107421875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 40, + "firecracker_rss_mb": 1883.5234375, + "fc_socket_count": 40, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 41, + "boot_time_s": 3.051, + "density_at_boot": 41, + "timestamp": 1773033148.0039015, + "vms_running": 41, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.762592315673828, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 41, + "firecracker_rss_mb": 1930.19140625, + "fc_socket_count": 41, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 42, + "boot_time_s": 3.047, + "density_at_boot": 42, + "timestamp": 1773033151.2032633, + "vms_running": 42, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.809150695800781, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 42, + "firecracker_rss_mb": 1977.37890625, + "fc_socket_count": 42, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 43, + "boot_time_s": 3.048, + "density_at_boot": 43, + "timestamp": 1773033154.4018452, + "vms_running": 43, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.859760284423828, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 43, + "firecracker_rss_mb": 2024.8203125, + "fc_socket_count": 43, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 44, + "boot_time_s": 3.051, + "density_at_boot": 44, + "timestamp": 1773033157.601361, + "vms_running": 44, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.906074523925781, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 44, + "firecracker_rss_mb": 2071.4921875, + "fc_socket_count": 44, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 45, + "boot_time_s": 3.009, + "density_at_boot": 45, + "timestamp": 1773033160.7611601, + "vms_running": 45, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.957592010498047, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 45, + "firecracker_rss_mb": 2118.421875, + "fc_socket_count": 45, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 46, + "boot_time_s": 3.171, + "density_at_boot": 46, + "timestamp": 1773033164.0836096, + "vms_running": 46, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.002906799316406, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 46, + "firecracker_rss_mb": 2165.34765625, + "fc_socket_count": 46, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 47, + "boot_time_s": 3.046, + "density_at_boot": 47, + "timestamp": 1773033167.2820804, + "vms_running": 47, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.047607421875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 47, + "firecracker_rss_mb": 2212.53515625, + "fc_socket_count": 47, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 48, + "boot_time_s": 3.047, + "density_at_boot": 48, + "timestamp": 1773033170.4816763, + "vms_running": 48, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.085933685302734, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 48, + "firecracker_rss_mb": 2259.46484375, + "fc_socket_count": 48, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 49, + "boot_time_s": 3.128, + "density_at_boot": 49, + "timestamp": 1773033173.761677, + "vms_running": 49, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.1317138671875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 49, + "firecracker_rss_mb": 2306.13671875, + "fc_socket_count": 49, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 50, + "boot_time_s": 3.05, + "density_at_boot": 50, + "timestamp": 1773033176.9637046, + "vms_running": 50, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.177833557128906, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 50, + "firecracker_rss_mb": 2353.83984375, + "fc_socket_count": 50, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 51, + "boot_time_s": 3.046, + "density_at_boot": 51, + "timestamp": 1773033180.1613538, + "vms_running": 51, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.221309661865234, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 51, + "firecracker_rss_mb": 2400.51171875, + "fc_socket_count": 51, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 52, + "boot_time_s": 3.05, + "density_at_boot": 52, + "timestamp": 1773033183.3628714, + "vms_running": 52, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 5.270954132080078, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 52, + "firecracker_rss_mb": 2447.18359375, + "fc_socket_count": 52, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 53, + "boot_time_s": 2.111, + "density_at_boot": 53, + "timestamp": 1773033185.6233401, + "vms_running": 53, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.3211517333984375, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 53, + "firecracker_rss_mb": 2494.11328125, + "fc_socket_count": 53, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 54, + "boot_time_s": 3.024, + "density_at_boot": 54, + "timestamp": 1773033188.8009796, + "vms_running": 54, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.3712005615234375, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 54, + "firecracker_rss_mb": 2541.296875, + "fc_socket_count": 54, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 55, + "boot_time_s": 3.133, + "density_at_boot": 55, + "timestamp": 1773033192.0828273, + "vms_running": 55, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.407588958740234, + "host_disk_used_gb": 2.0448074340820312, + "tap_count": 55, + "firecracker_rss_mb": 2587.96484375, + "fc_socket_count": 55, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 56, + "boot_time_s": 3.007, + "density_at_boot": 56, + "timestamp": 1773033195.2397757, + "vms_running": 56, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.461029052734375, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 56, + "firecracker_rss_mb": 2635.40625, + "fc_socket_count": 56, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 57, + "boot_time_s": 3.012, + "density_at_boot": 57, + "timestamp": 1773033198.4022074, + "vms_running": 57, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.516471862792969, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 57, + "firecracker_rss_mb": 2682.5859375, + "fc_socket_count": 57, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 58, + "boot_time_s": 2.065, + "density_at_boot": 58, + "timestamp": 1773033200.6183062, + "vms_running": 58, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 5.566684722900391, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 58, + "firecracker_rss_mb": 2730.546875, + "fc_socket_count": 58, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 59, + "boot_time_s": 2.995, + "density_at_boot": 59, + "timestamp": 1773033203.7625341, + "vms_running": 59, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.616291046142578, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 59, + "firecracker_rss_mb": 2777.98828125, + "fc_socket_count": 59, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 60, + "boot_time_s": 3.005, + "density_at_boot": 60, + "timestamp": 1773033206.9203105, + "vms_running": 60, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.656620025634766, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 60, + "firecracker_rss_mb": 2824.65234375, + "fc_socket_count": 60, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 61, + "boot_time_s": 2.968, + "density_at_boot": 61, + "timestamp": 1773033210.0405595, + "vms_running": 61, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.709175109863281, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 61, + "firecracker_rss_mb": 2871.06640625, + "fc_socket_count": 61, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 62, + "boot_time_s": 2.968, + "density_at_boot": 62, + "timestamp": 1773033213.160054, + "vms_running": 62, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.756771087646484, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 62, + "firecracker_rss_mb": 2917.48046875, + "fc_socket_count": 62, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 63, + "boot_time_s": 3.09, + "density_at_boot": 63, + "timestamp": 1773033216.403268, + "vms_running": 63, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.798877716064453, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 63, + "firecracker_rss_mb": 2964.92578125, + "fc_socket_count": 63, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 64, + "boot_time_s": 2.064, + "density_at_boot": 64, + "timestamp": 1773033218.6201143, + "vms_running": 64, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.846565246582031, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 64, + "firecracker_rss_mb": 3012.11328125, + "fc_socket_count": 64, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 65, + "boot_time_s": 2.039, + "density_at_boot": 65, + "timestamp": 1773033220.8116317, + "vms_running": 65, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.889556884765625, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 65, + "firecracker_rss_mb": 3058.78515625, + "fc_socket_count": 65, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 66, + "boot_time_s": 3.036, + "density_at_boot": 66, + "timestamp": 1773033224.000127, + "vms_running": 66, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.9334716796875, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 66, + "firecracker_rss_mb": 3105.72265625, + "fc_socket_count": 66, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 67, + "boot_time_s": 2.274, + "density_at_boot": 67, + "timestamp": 1773033226.4246364, + "vms_running": 67, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.988681793212891, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 67, + "firecracker_rss_mb": 3152.6484375, + "fc_socket_count": 67, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 68, + "boot_time_s": 3.103, + "density_at_boot": 68, + "timestamp": 1773033229.6829405, + "vms_running": 68, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 6.028797149658203, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 68, + "firecracker_rss_mb": 3199.83203125, + "fc_socket_count": 68, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 69, + "boot_time_s": 3.05, + "density_at_boot": 69, + "timestamp": 1773033232.883963, + "vms_running": 69, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.079540252685547, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 69, + "firecracker_rss_mb": 3247.015625, + "fc_socket_count": 69, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 70, + "boot_time_s": 3.047, + "density_at_boot": 70, + "timestamp": 1773033236.083304, + "vms_running": 70, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.1288909912109375, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 70, + "firecracker_rss_mb": 3293.94140625, + "fc_socket_count": 70, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 71, + "boot_time_s": 3.045, + "density_at_boot": 71, + "timestamp": 1773033239.2812428, + "vms_running": 71, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.164848327636719, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 71, + "firecracker_rss_mb": 3340.8671875, + "fc_socket_count": 71, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 72, + "boot_time_s": 3.007, + "density_at_boot": 72, + "timestamp": 1773033242.4412746, + "vms_running": 72, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.211551666259766, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 72, + "firecracker_rss_mb": 3388.05078125, + "fc_socket_count": 72, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 73, + "boot_time_s": 3.088, + "density_at_boot": 73, + "timestamp": 1773033245.683507, + "vms_running": 73, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.2582550048828125, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 73, + "firecracker_rss_mb": 3435.23828125, + "fc_socket_count": 73, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 74, + "boot_time_s": 2.142, + "density_at_boot": 74, + "timestamp": 1773033247.978695, + "vms_running": 74, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.303688049316406, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 74, + "firecracker_rss_mb": 3481.90625, + "fc_socket_count": 74, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 75, + "boot_time_s": 2.031, + "density_at_boot": 75, + "timestamp": 1773033250.163482, + "vms_running": 75, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.348236083984375, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 75, + "firecracker_rss_mb": 3528.8359375, + "fc_socket_count": 75, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 76, + "boot_time_s": 2.186, + "density_at_boot": 76, + "timestamp": 1773033252.5023098, + "vms_running": 76, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 6.395847320556641, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 76, + "firecracker_rss_mb": 3576.01953125, + "fc_socket_count": 76, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 77, + "boot_time_s": 3.112, + "density_at_boot": 77, + "timestamp": 1773033255.7646894, + "vms_running": 77, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.447135925292969, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 77, + "firecracker_rss_mb": 3622.69140625, + "fc_socket_count": 77, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 78, + "boot_time_s": 2.997, + "density_at_boot": 78, + "timestamp": 1773033258.9184716, + "vms_running": 78, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 6.4872283935546875, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 78, + "firecracker_rss_mb": 3670.39453125, + "fc_socket_count": 78, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 79, + "boot_time_s": 3.011, + "density_at_boot": 79, + "timestamp": 1773033262.0819917, + "vms_running": 79, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.534366607666016, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 79, + "firecracker_rss_mb": 3717.3203125, + "fc_socket_count": 79, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 80, + "boot_time_s": 3.082, + "density_at_boot": 80, + "timestamp": 1773033265.3196058, + "vms_running": 80, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.580863952636719, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 80, + "firecracker_rss_mb": 3763.73046875, + "fc_socket_count": 80, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 81, + "boot_time_s": 2.965, + "density_at_boot": 81, + "timestamp": 1773033268.439817, + "vms_running": 81, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.624134063720703, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 81, + "firecracker_rss_mb": 3810.14453125, + "fc_socket_count": 81, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 82, + "boot_time_s": 3.007, + "density_at_boot": 82, + "timestamp": 1773033271.6033342, + "vms_running": 82, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 6.6730499267578125, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 82, + "firecracker_rss_mb": 3856.5546875, + "fc_socket_count": 82, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 83, + "boot_time_s": 2.999, + "density_at_boot": 83, + "timestamp": 1773033274.7591214, + "vms_running": 83, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.721355438232422, + "host_disk_used_gb": 2.045482635498047, + "tap_count": 83, + "firecracker_rss_mb": 3902.96875, + "fc_socket_count": 83, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 84, + "boot_time_s": 3.009, + "density_at_boot": 84, + "timestamp": 1773033277.9239209, + "vms_running": 84, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.7634429931640625, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 84, + "firecracker_rss_mb": 3950.15234375, + "fc_socket_count": 84, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 85, + "boot_time_s": 3.122, + "density_at_boot": 85, + "timestamp": 1773033281.2036185, + "vms_running": 85, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 6.805477142333984, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 85, + "firecracker_rss_mb": 3996.56640625, + "fc_socket_count": 85, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 86, + "boot_time_s": 3.124, + "density_at_boot": 86, + "timestamp": 1773033284.4832091, + "vms_running": 86, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.858394622802734, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 86, + "firecracker_rss_mb": 4042.98046875, + "fc_socket_count": 86, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 87, + "boot_time_s": 2.996, + "density_at_boot": 87, + "timestamp": 1773033287.63918, + "vms_running": 87, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 6.907325744628906, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 87, + "firecracker_rss_mb": 4090.42578125, + "fc_socket_count": 87, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 88, + "boot_time_s": 3.25, + "density_at_boot": 88, + "timestamp": 1773033291.0429933, + "vms_running": 88, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.96649169921875, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 88, + "firecracker_rss_mb": 4136.8359375, + "fc_socket_count": 88, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 89, + "boot_time_s": 3.04, + "density_at_boot": 89, + "timestamp": 1773033294.2414389, + "vms_running": 89, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.016696929931641, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 89, + "firecracker_rss_mb": 4184.28125, + "fc_socket_count": 89, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 90, + "boot_time_s": 3.127, + "density_at_boot": 90, + "timestamp": 1773033297.5242565, + "vms_running": 90, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.061672210693359, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 90, + "firecracker_rss_mb": 4230.953125, + "fc_socket_count": 90, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 91, + "boot_time_s": 3.121, + "density_at_boot": 91, + "timestamp": 1773033300.8026967, + "vms_running": 91, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.102863311767578, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 91, + "firecracker_rss_mb": 4278.13671875, + "fc_socket_count": 91, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 92, + "boot_time_s": 3.125, + "density_at_boot": 92, + "timestamp": 1773033304.0850515, + "vms_running": 92, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.147693634033203, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 92, + "firecracker_rss_mb": 4325.83984375, + "fc_socket_count": 92, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 93, + "boot_time_s": 2.18, + "density_at_boot": 93, + "timestamp": 1773033306.4212089, + "vms_running": 93, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.193912506103516, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 93, + "firecracker_rss_mb": 4372.25, + "fc_socket_count": 93, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 94, + "boot_time_s": 3.104, + "density_at_boot": 94, + "timestamp": 1773033309.6850111, + "vms_running": 94, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.243099212646484, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 94, + "firecracker_rss_mb": 4418.40625, + "fc_socket_count": 94, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 95, + "boot_time_s": 2.189, + "density_at_boot": 95, + "timestamp": 1773033312.0331566, + "vms_running": 95, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.286735534667969, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 95, + "firecracker_rss_mb": 4465.3359375, + "fc_socket_count": 95, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 96, + "boot_time_s": 3.088, + "density_at_boot": 96, + "timestamp": 1773033315.280903, + "vms_running": 96, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.325340270996094, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 96, + "firecracker_rss_mb": 4512.265625, + "fc_socket_count": 96, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 97, + "boot_time_s": 3.044, + "density_at_boot": 97, + "timestamp": 1773033318.4851127, + "vms_running": 97, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.373432159423828, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 97, + "firecracker_rss_mb": 4559.19921875, + "fc_socket_count": 97, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 98, + "boot_time_s": 3.04, + "density_at_boot": 98, + "timestamp": 1773033321.6831727, + "vms_running": 98, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.423236846923828, + "host_disk_used_gb": 2.0467262268066406, + "tap_count": 98, + "firecracker_rss_mb": 4606.38671875, + "fc_socket_count": 98, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 99, + "boot_time_s": 3.124, + "density_at_boot": 99, + "timestamp": 1773033324.964652, + "vms_running": 99, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.467609405517578, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 99, + "firecracker_rss_mb": 4653.05859375, + "fc_socket_count": 99, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 100, + "boot_time_s": 3.122, + "density_at_boot": 100, + "timestamp": 1773033328.2430675, + "vms_running": 100, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.511039733886719, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 100, + "firecracker_rss_mb": 4699.46875, + "fc_socket_count": 100, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 101, + "boot_time_s": 3.127, + "density_at_boot": 101, + "timestamp": 1773033331.522668, + "vms_running": 101, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.559967041015625, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 101, + "firecracker_rss_mb": 4746.3984375, + "fc_socket_count": 101, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 102, + "boot_time_s": 2.18, + "density_at_boot": 102, + "timestamp": 1773033333.8610601, + "vms_running": 102, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.608421325683594, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 102, + "firecracker_rss_mb": 4793.0703125, + "fc_socket_count": 102, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 103, + "boot_time_s": 3.025, + "density_at_boot": 103, + "timestamp": 1773033337.0418603, + "vms_running": 103, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.656368255615234, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 103, + "firecracker_rss_mb": 4840.76953125, + "fc_socket_count": 103, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 104, + "boot_time_s": 2.184, + "density_at_boot": 104, + "timestamp": 1773033339.383744, + "vms_running": 104, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.709503173828125, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 104, + "firecracker_rss_mb": 4887.95703125, + "fc_socket_count": 104, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 105, + "boot_time_s": 3.184, + "density_at_boot": 105, + "timestamp": 1773033342.721289, + "vms_running": 105, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.748188018798828, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 105, + "firecracker_rss_mb": 4934.625, + "fc_socket_count": 105, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 106, + "boot_time_s": 3.08, + "density_at_boot": 106, + "timestamp": 1773033345.959677, + "vms_running": 106, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.791416168212891, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 106, + "firecracker_rss_mb": 4982.06640625, + "fc_socket_count": 106, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 107, + "boot_time_s": 2.106, + "density_at_boot": 107, + "timestamp": 1773033348.2202184, + "vms_running": 107, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 7.840679168701172, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 107, + "firecracker_rss_mb": 5028.4765625, + "fc_socket_count": 107, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 108, + "boot_time_s": 3.064, + "density_at_boot": 108, + "timestamp": 1773033351.4419806, + "vms_running": 108, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.8821258544921875, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 108, + "firecracker_rss_mb": 5075.40234375, + "fc_socket_count": 108, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 109, + "boot_time_s": 3.285, + "density_at_boot": 109, + "timestamp": 1773033354.881558, + "vms_running": 109, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.931728363037109, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 109, + "firecracker_rss_mb": 5122.328125, + "fc_socket_count": 109, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 110, + "boot_time_s": 2.181, + "density_at_boot": 110, + "timestamp": 1773033357.2215796, + "vms_running": 110, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.985015869140625, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 110, + "firecracker_rss_mb": 5169.25, + "fc_socket_count": 110, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 111, + "boot_time_s": 3.026, + "density_at_boot": 111, + "timestamp": 1773033360.4034083, + "vms_running": 111, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.026233673095703, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 111, + "firecracker_rss_mb": 5215.921875, + "fc_socket_count": 111, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 112, + "boot_time_s": 3.039, + "density_at_boot": 112, + "timestamp": 1773033363.60248, + "vms_running": 112, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.06964111328125, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 112, + "firecracker_rss_mb": 5262.58984375, + "fc_socket_count": 112, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 113, + "boot_time_s": 3.121, + "density_at_boot": 113, + "timestamp": 1773033366.8814447, + "vms_running": 113, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.123348236083984, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 113, + "firecracker_rss_mb": 5309.26171875, + "fc_socket_count": 113, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 114, + "boot_time_s": 3.135, + "density_at_boot": 114, + "timestamp": 1773033370.1746638, + "vms_running": 114, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.168418884277344, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 114, + "firecracker_rss_mb": 5356.19140625, + "fc_socket_count": 114, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 115, + "boot_time_s": 3.112, + "density_at_boot": 115, + "timestamp": 1773033373.4441922, + "vms_running": 115, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.210132598876953, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 115, + "firecracker_rss_mb": 5403.37890625, + "fc_socket_count": 115, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 116, + "boot_time_s": 3.121, + "density_at_boot": 116, + "timestamp": 1773033376.7231078, + "vms_running": 116, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.251083374023438, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 116, + "firecracker_rss_mb": 5450.046875, + "fc_socket_count": 116, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 117, + "boot_time_s": 3.122, + "density_at_boot": 117, + "timestamp": 1773033380.0035434, + "vms_running": 117, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.304367065429688, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 117, + "firecracker_rss_mb": 5496.9765625, + "fc_socket_count": 117, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 118, + "boot_time_s": 3.202, + "density_at_boot": 118, + "timestamp": 1773033383.3633437, + "vms_running": 118, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.354461669921875, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 118, + "firecracker_rss_mb": 5543.8984375, + "fc_socket_count": 118, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 119, + "boot_time_s": 3.117, + "density_at_boot": 119, + "timestamp": 1773033386.6418316, + "vms_running": 119, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.395759582519531, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 119, + "firecracker_rss_mb": 5590.56640625, + "fc_socket_count": 119, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 120, + "boot_time_s": 3.123, + "density_at_boot": 120, + "timestamp": 1773033389.9224994, + "vms_running": 120, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.447036743164062, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 120, + "firecracker_rss_mb": 5636.97265625, + "fc_socket_count": 120, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 121, + "boot_time_s": 3.076, + "density_at_boot": 121, + "timestamp": 1773033393.1599932, + "vms_running": 121, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.49530029296875, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 121, + "firecracker_rss_mb": 5684.15234375, + "fc_socket_count": 121, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 122, + "boot_time_s": 3.082, + "density_at_boot": 122, + "timestamp": 1773033396.4016879, + "vms_running": 122, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.541004180908203, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 122, + "firecracker_rss_mb": 5731.33984375, + "fc_socket_count": 122, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 123, + "boot_time_s": 3.04, + "density_at_boot": 123, + "timestamp": 1773033399.601394, + "vms_running": 123, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.587997436523438, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 123, + "firecracker_rss_mb": 5778.00390625, + "fc_socket_count": 123, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 124, + "boot_time_s": 3.201, + "density_at_boot": 124, + "timestamp": 1773033402.96306, + "vms_running": 124, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.630805969238281, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 124, + "firecracker_rss_mb": 5824.671875, + "fc_socket_count": 124, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 125, + "boot_time_s": 3.117, + "density_at_boot": 125, + "timestamp": 1773033406.2411644, + "vms_running": 125, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.680839538574219, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 125, + "firecracker_rss_mb": 5871.0859375, + "fc_socket_count": 125, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 126, + "boot_time_s": 3.08, + "density_at_boot": 126, + "timestamp": 1773033409.4800408, + "vms_running": 126, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 8.728694915771484, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 126, + "firecracker_rss_mb": 5918.53125, + "fc_socket_count": 126, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 127, + "boot_time_s": 3.088, + "density_at_boot": 127, + "timestamp": 1773033412.7238917, + "vms_running": 127, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.772705078125, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 127, + "firecracker_rss_mb": 5965.71484375, + "fc_socket_count": 127, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 128, + "boot_time_s": 3.117, + "density_at_boot": 128, + "timestamp": 1773033416.000301, + "vms_running": 128, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.832965850830078, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 128, + "firecracker_rss_mb": 6012.640625, + "fc_socket_count": 128, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 129, + "boot_time_s": 3.119, + "density_at_boot": 129, + "timestamp": 1773033419.281909, + "vms_running": 129, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.882610321044922, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 129, + "firecracker_rss_mb": 6059.56640625, + "fc_socket_count": 129, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 130, + "boot_time_s": 3.117, + "density_at_boot": 130, + "timestamp": 1773033422.562466, + "vms_running": 130, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.926074981689453, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 130, + "firecracker_rss_mb": 6107.0078125, + "fc_socket_count": 130, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 131, + "boot_time_s": 3.121, + "density_at_boot": 131, + "timestamp": 1773033425.844859, + "vms_running": 131, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.970325469970703, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 131, + "firecracker_rss_mb": 6153.421875, + "fc_socket_count": 131, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 132, + "boot_time_s": 2.254, + "density_at_boot": 132, + "timestamp": 1773033428.2608886, + "vms_running": 132, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.01382064819336, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 132, + "firecracker_rss_mb": 6200.08984375, + "fc_socket_count": 132, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 133, + "boot_time_s": 3.099, + "density_at_boot": 133, + "timestamp": 1773033431.521233, + "vms_running": 133, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 9.0545654296875, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 133, + "firecracker_rss_mb": 6246.50390625, + "fc_socket_count": 133, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 134, + "boot_time_s": 3.121, + "density_at_boot": 134, + "timestamp": 1773033434.803238, + "vms_running": 134, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 9.105091094970703, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 134, + "firecracker_rss_mb": 6293.42578125, + "fc_socket_count": 134, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 135, + "boot_time_s": 3.118, + "density_at_boot": 135, + "timestamp": 1773033438.0817564, + "vms_running": 135, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.156326293945312, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 135, + "firecracker_rss_mb": 6340.34765625, + "fc_socket_count": 135, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 136, + "boot_time_s": 3.123, + "density_at_boot": 136, + "timestamp": 1773033441.3631392, + "vms_running": 136, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.193977355957031, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 136, + "firecracker_rss_mb": 6387.27734375, + "fc_socket_count": 136, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 137, + "boot_time_s": 3.119, + "density_at_boot": 137, + "timestamp": 1773033444.6434557, + "vms_running": 137, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.247077941894531, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 137, + "firecracker_rss_mb": 6433.9453125, + "fc_socket_count": 137, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 138, + "boot_time_s": 3.075, + "density_at_boot": 138, + "timestamp": 1773033447.87982, + "vms_running": 138, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.296798706054688, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 138, + "firecracker_rss_mb": 6480.35546875, + "fc_socket_count": 138, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 139, + "boot_time_s": 2.222, + "density_at_boot": 139, + "timestamp": 1773033450.2640986, + "vms_running": 139, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.344768524169922, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 139, + "firecracker_rss_mb": 6527.54296875, + "fc_socket_count": 139, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 140, + "boot_time_s": 3.1, + "density_at_boot": 140, + "timestamp": 1773033453.524573, + "vms_running": 140, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.38943862915039, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 140, + "firecracker_rss_mb": 6574.21484375, + "fc_socket_count": 140, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 141, + "boot_time_s": 3.117, + "density_at_boot": 141, + "timestamp": 1773033456.803698, + "vms_running": 141, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.433296203613281, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 141, + "firecracker_rss_mb": 6622.17578125, + "fc_socket_count": 141, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 142, + "boot_time_s": 3.115, + "density_at_boot": 142, + "timestamp": 1773033460.0809586, + "vms_running": 142, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.485233306884766, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 142, + "firecracker_rss_mb": 6669.10546875, + "fc_socket_count": 142, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 143, + "boot_time_s": 2.257, + "density_at_boot": 143, + "timestamp": 1773033462.5032816, + "vms_running": 143, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.534984588623047, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 143, + "firecracker_rss_mb": 6715.7734375, + "fc_socket_count": 143, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 144, + "boot_time_s": 3.092, + "density_at_boot": 144, + "timestamp": 1773033465.7614236, + "vms_running": 144, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.581172943115234, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 144, + "firecracker_rss_mb": 6762.18359375, + "fc_socket_count": 144, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 145, + "boot_time_s": 2.259, + "density_at_boot": 145, + "timestamp": 1773033468.1824205, + "vms_running": 145, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.623035430908203, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 145, + "firecracker_rss_mb": 6808.59375, + "fc_socket_count": 145, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 146, + "boot_time_s": 2.237, + "density_at_boot": 146, + "timestamp": 1773033470.5823827, + "vms_running": 146, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.670127868652344, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 146, + "firecracker_rss_mb": 6855.7734375, + "fc_socket_count": 146, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 147, + "boot_time_s": 3.099, + "density_at_boot": 147, + "timestamp": 1773033473.8449368, + "vms_running": 147, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.725379943847656, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 147, + "firecracker_rss_mb": 6903.4765625, + "fc_socket_count": 147, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 148, + "boot_time_s": 3.113, + "density_at_boot": 148, + "timestamp": 1773033477.121257, + "vms_running": 148, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.766246795654297, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 148, + "firecracker_rss_mb": 6950.1484375, + "fc_socket_count": 148, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 149, + "boot_time_s": 2.34, + "density_at_boot": 149, + "timestamp": 1773033479.6245906, + "vms_running": 149, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.817317962646484, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 149, + "firecracker_rss_mb": 6996.8203125, + "fc_socket_count": 149, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 150, + "boot_time_s": 3.093, + "density_at_boot": 150, + "timestamp": 1773033482.8818614, + "vms_running": 150, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.861000061035156, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 150, + "firecracker_rss_mb": 7043.4921875, + "fc_socket_count": 150, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 151, + "boot_time_s": 3.116, + "density_at_boot": 151, + "timestamp": 1773033486.1640375, + "vms_running": 151, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.906044006347656, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 151, + "firecracker_rss_mb": 7090.15625, + "fc_socket_count": 151, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 152, + "boot_time_s": 3.193, + "density_at_boot": 152, + "timestamp": 1773033489.521806, + "vms_running": 152, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.950984954833984, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 152, + "firecracker_rss_mb": 7136.828125, + "fc_socket_count": 152, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 153, + "boot_time_s": 3.194, + "density_at_boot": 153, + "timestamp": 1773033492.8805733, + "vms_running": 153, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.998855590820312, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 153, + "firecracker_rss_mb": 7183.75390625, + "fc_socket_count": 153, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 154, + "boot_time_s": 2.252, + "density_at_boot": 154, + "timestamp": 1773033495.3022184, + "vms_running": 154, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.040069580078125, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 154, + "firecracker_rss_mb": 7230.42578125, + "fc_socket_count": 154, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 155, + "boot_time_s": 3.254, + "density_at_boot": 155, + "timestamp": 1773033498.7247493, + "vms_running": 155, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.091270446777344, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 155, + "firecracker_rss_mb": 7277.09375, + "fc_socket_count": 155, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 156, + "boot_time_s": 3.193, + "density_at_boot": 156, + "timestamp": 1773033502.0826788, + "vms_running": 156, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.131889343261719, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 156, + "firecracker_rss_mb": 7324.26953125, + "fc_socket_count": 156, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 157, + "boot_time_s": 3.119, + "density_at_boot": 157, + "timestamp": 1773033505.362828, + "vms_running": 157, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.181037902832031, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 157, + "firecracker_rss_mb": 7370.94140625, + "fc_socket_count": 157, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 158, + "boot_time_s": 3.112, + "density_at_boot": 158, + "timestamp": 1773033508.6444862, + "vms_running": 158, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.230438232421875, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 158, + "firecracker_rss_mb": 7417.87109375, + "fc_socket_count": 158, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 159, + "boot_time_s": 3.109, + "density_at_boot": 159, + "timestamp": 1773033511.9205093, + "vms_running": 159, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.284061431884766, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 159, + "firecracker_rss_mb": 7464.796875, + "fc_socket_count": 159, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 160, + "boot_time_s": 3.194, + "density_at_boot": 160, + "timestamp": 1773033515.2842944, + "vms_running": 160, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.324714660644531, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 160, + "firecracker_rss_mb": 7511.203125, + "fc_socket_count": 160, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 161, + "boot_time_s": 2.253, + "density_at_boot": 161, + "timestamp": 1773033517.7042155, + "vms_running": 161, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.376792907714844, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 161, + "firecracker_rss_mb": 7558.12890625, + "fc_socket_count": 161, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 162, + "boot_time_s": 3.094, + "density_at_boot": 162, + "timestamp": 1773033520.9644217, + "vms_running": 162, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.431446075439453, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 162, + "firecracker_rss_mb": 7605.0546875, + "fc_socket_count": 162, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 163, + "boot_time_s": 3.11, + "density_at_boot": 163, + "timestamp": 1773033524.243907, + "vms_running": 163, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.468460083007812, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 163, + "firecracker_rss_mb": 7651.98046875, + "fc_socket_count": 163, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 164, + "boot_time_s": 3.191, + "density_at_boot": 164, + "timestamp": 1773033527.6043, + "vms_running": 164, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.510318756103516, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 164, + "firecracker_rss_mb": 7698.90625, + "fc_socket_count": 164, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 165, + "boot_time_s": 3.108, + "density_at_boot": 165, + "timestamp": 1773033530.8813622, + "vms_running": 165, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.557815551757812, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 165, + "firecracker_rss_mb": 7745.8359375, + "fc_socket_count": 165, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 166, + "boot_time_s": 3.123, + "density_at_boot": 166, + "timestamp": 1773033534.1663275, + "vms_running": 166, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.608741760253906, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 166, + "firecracker_rss_mb": 7793.01953125, + "fc_socket_count": 166, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 167, + "boot_time_s": 3.189, + "density_at_boot": 167, + "timestamp": 1773033537.5240815, + "vms_running": 167, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.653961181640625, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 167, + "firecracker_rss_mb": 7839.94140625, + "fc_socket_count": 167, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 168, + "boot_time_s": 2.25, + "density_at_boot": 168, + "timestamp": 1773033539.9457948, + "vms_running": 168, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.698810577392578, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 168, + "firecracker_rss_mb": 7886.61328125, + "fc_socket_count": 168, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 169, + "boot_time_s": 3.168, + "density_at_boot": 169, + "timestamp": 1773033543.2839813, + "vms_running": 169, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.747535705566406, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 169, + "firecracker_rss_mb": 7933.5390625, + "fc_socket_count": 169, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 170, + "boot_time_s": 3.347, + "density_at_boot": 170, + "timestamp": 1773033546.8029087, + "vms_running": 170, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.788501739501953, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 170, + "firecracker_rss_mb": 7980.2109375, + "fc_socket_count": 170, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 171, + "boot_time_s": 3.111, + "density_at_boot": 171, + "timestamp": 1773033550.0837052, + "vms_running": 171, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.838539123535156, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 171, + "firecracker_rss_mb": 8026.625, + "fc_socket_count": 171, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 172, + "boot_time_s": 3.107, + "density_at_boot": 172, + "timestamp": 1773033553.3607836, + "vms_running": 172, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.891731262207031, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 172, + "firecracker_rss_mb": 8073.5546875, + "fc_socket_count": 172, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 173, + "boot_time_s": 3.191, + "density_at_boot": 173, + "timestamp": 1773033556.7229428, + "vms_running": 173, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.934406280517578, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 173, + "firecracker_rss_mb": 8119.96484375, + "fc_socket_count": 173, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 174, + "boot_time_s": 3.111, + "density_at_boot": 174, + "timestamp": 1773033560.0019217, + "vms_running": 174, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 10.979808807373047, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 174, + "firecracker_rss_mb": 8166.890625, + "fc_socket_count": 174, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 175, + "boot_time_s": 3.111, + "density_at_boot": 175, + "timestamp": 1773033563.2828329, + "vms_running": 175, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.024150848388672, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 175, + "firecracker_rss_mb": 8213.55859375, + "fc_socket_count": 175, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 176, + "boot_time_s": 3.068, + "density_at_boot": 176, + "timestamp": 1773033566.5202913, + "vms_running": 176, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.070877075195312, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 176, + "firecracker_rss_mb": 8259.96484375, + "fc_socket_count": 176, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 177, + "boot_time_s": 3.15, + "density_at_boot": 177, + "timestamp": 1773033569.841767, + "vms_running": 177, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.11007308959961, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 177, + "firecracker_rss_mb": 8306.89453125, + "fc_socket_count": 177, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 178, + "boot_time_s": 3.109, + "density_at_boot": 178, + "timestamp": 1773033573.1206295, + "vms_running": 178, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.160285949707031, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 178, + "firecracker_rss_mb": 8353.82421875, + "fc_socket_count": 178, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 179, + "boot_time_s": 2.253, + "density_at_boot": 179, + "timestamp": 1773033575.5447557, + "vms_running": 179, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.212104797363281, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 179, + "firecracker_rss_mb": 8400.75, + "fc_socket_count": 179, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 180, + "boot_time_s": 3.165, + "density_at_boot": 180, + "timestamp": 1773033578.8825028, + "vms_running": 180, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.261924743652344, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 180, + "firecracker_rss_mb": 8447.9375, + "fc_socket_count": 180, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 181, + "boot_time_s": 3.193, + "density_at_boot": 181, + "timestamp": 1773033582.2439106, + "vms_running": 181, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.309494018554688, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 181, + "firecracker_rss_mb": 8494.86328125, + "fc_socket_count": 181, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 182, + "boot_time_s": 3.188, + "density_at_boot": 182, + "timestamp": 1773033585.6021996, + "vms_running": 182, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.352672576904297, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 182, + "firecracker_rss_mb": 8541.2734375, + "fc_socket_count": 182, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 183, + "boot_time_s": 3.149, + "density_at_boot": 183, + "timestamp": 1773033588.9205325, + "vms_running": 183, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.397899627685547, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 183, + "firecracker_rss_mb": 8588.45703125, + "fc_socket_count": 183, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 184, + "boot_time_s": 3.157, + "density_at_boot": 184, + "timestamp": 1773033592.2446215, + "vms_running": 184, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.445987701416016, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 184, + "firecracker_rss_mb": 8635.12890625, + "fc_socket_count": 184, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 185, + "boot_time_s": 3.19, + "density_at_boot": 185, + "timestamp": 1773033595.6052225, + "vms_running": 185, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.482105255126953, + "host_disk_used_gb": 2.064289093017578, + "tap_count": 185, + "firecracker_rss_mb": 8682.3125, + "fc_socket_count": 185, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 186, + "boot_time_s": 3.188, + "density_at_boot": 186, + "timestamp": 1773033598.9635153, + "vms_running": 186, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.541004180908203, + "host_disk_used_gb": 2.068195343017578, + "tap_count": 186, + "firecracker_rss_mb": 8729.23828125, + "fc_socket_count": 186, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 187, + "boot_time_s": 2.226, + "density_at_boot": 187, + "timestamp": 1773033601.3632512, + "vms_running": 187, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.587959289550781, + "host_disk_used_gb": 2.0681991577148438, + "tap_count": 187, + "firecracker_rss_mb": 8775.90625, + "fc_socket_count": 187, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 188, + "boot_time_s": 3.346, + "density_at_boot": 188, + "timestamp": 1773033604.8829737, + "vms_running": 188, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.639976501464844, + "host_disk_used_gb": 2.068256378173828, + "tap_count": 188, + "firecracker_rss_mb": 8822.578125, + "fc_socket_count": 188, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 189, + "boot_time_s": 3.187, + "density_at_boot": 189, + "timestamp": 1773033608.2422018, + "vms_running": 189, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.687469482421875, + "host_disk_used_gb": 2.0682373046875, + "tap_count": 189, + "firecracker_rss_mb": 8868.98828125, + "fc_socket_count": 189, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 190, + "boot_time_s": 3.271, + "density_at_boot": 190, + "timestamp": 1773033611.6846218, + "vms_running": 190, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.74105453491211, + "host_disk_used_gb": 2.0682373046875, + "tap_count": 190, + "firecracker_rss_mb": 8916.17578125, + "fc_socket_count": 190, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 191, + "boot_time_s": 2.209, + "density_at_boot": 191, + "timestamp": 1773033614.0609727, + "vms_running": 191, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.793479919433594, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 191, + "firecracker_rss_mb": 8963.1015625, + "fc_socket_count": 191, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 192, + "boot_time_s": 2.264, + "density_at_boot": 192, + "timestamp": 1773033616.501715, + "vms_running": 192, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.839092254638672, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 192, + "firecracker_rss_mb": 9009.2578125, + "fc_socket_count": 192, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 193, + "boot_time_s": 3.328, + "density_at_boot": 193, + "timestamp": 1773033620.0044794, + "vms_running": 193, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.886859893798828, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 193, + "firecracker_rss_mb": 9055.671875, + "fc_socket_count": 193, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 194, + "boot_time_s": 3.187, + "density_at_boot": 194, + "timestamp": 1773033623.3625393, + "vms_running": 194, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 11.928947448730469, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 194, + "firecracker_rss_mb": 9102.6015625, + "fc_socket_count": 194, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 195, + "boot_time_s": 3.194, + "density_at_boot": 195, + "timestamp": 1773033626.7250767, + "vms_running": 195, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.971641540527344, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 195, + "firecracker_rss_mb": 9149.26953125, + "fc_socket_count": 195, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 196, + "boot_time_s": 3.185, + "density_at_boot": 196, + "timestamp": 1773033630.0824122, + "vms_running": 196, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.018150329589844, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 196, + "firecracker_rss_mb": 9196.453125, + "fc_socket_count": 196, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 197, + "boot_time_s": 3.188, + "density_at_boot": 197, + "timestamp": 1773033633.4426615, + "vms_running": 197, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 12.065910339355469, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 197, + "firecracker_rss_mb": 9243.3828125, + "fc_socket_count": 197, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 198, + "boot_time_s": 3.187, + "density_at_boot": 198, + "timestamp": 1773033636.802098, + "vms_running": 198, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.115619659423828, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 198, + "firecracker_rss_mb": 9290.30859375, + "fc_socket_count": 198, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 199, + "boot_time_s": 3.141, + "density_at_boot": 199, + "timestamp": 1773033640.119371, + "vms_running": 199, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.157161712646484, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 199, + "firecracker_rss_mb": 9337.23828125, + "fc_socket_count": 199, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 200, + "boot_time_s": 3.15, + "density_at_boot": 200, + "timestamp": 1773033643.4410403, + "vms_running": 200, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.199546813964844, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 200, + "firecracker_rss_mb": 9383.65234375, + "fc_socket_count": 200, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 201, + "boot_time_s": 3.187, + "density_at_boot": 201, + "timestamp": 1773033646.8031938, + "vms_running": 201, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.243377685546875, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 201, + "firecracker_rss_mb": 9430.83984375, + "fc_socket_count": 201, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 202, + "boot_time_s": 2.21, + "density_at_boot": 202, + "timestamp": 1773033649.1886933, + "vms_running": 202, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.294654846191406, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 202, + "firecracker_rss_mb": 9477.51171875, + "fc_socket_count": 202, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 203, + "boot_time_s": 3.117, + "density_at_boot": 203, + "timestamp": 1773033652.4823601, + "vms_running": 203, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 12.346118927001953, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 203, + "firecracker_rss_mb": 9524.9609375, + "fc_socket_count": 203, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 204, + "boot_time_s": 3.184, + "density_at_boot": 204, + "timestamp": 1773033655.8429387, + "vms_running": 204, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.397769927978516, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 204, + "firecracker_rss_mb": 9571.6328125, + "fc_socket_count": 204, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 205, + "boot_time_s": 3.185, + "density_at_boot": 205, + "timestamp": 1773033659.2011416, + "vms_running": 205, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.447380065917969, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 205, + "firecracker_rss_mb": 9618.5546875, + "fc_socket_count": 205, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 206, + "boot_time_s": 3.141, + "density_at_boot": 206, + "timestamp": 1773033662.5197165, + "vms_running": 206, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.492847442626953, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 206, + "firecracker_rss_mb": 9665.484375, + "fc_socket_count": 206, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 207, + "boot_time_s": 3.183, + "density_at_boot": 207, + "timestamp": 1773033665.8796723, + "vms_running": 207, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.531898498535156, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 207, + "firecracker_rss_mb": 9712.1484375, + "fc_socket_count": 207, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 208, + "boot_time_s": 3.224, + "density_at_boot": 208, + "timestamp": 1773033669.2808225, + "vms_running": 208, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 12.575054168701172, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 208, + "firecracker_rss_mb": 9759.08203125, + "fc_socket_count": 208, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 209, + "boot_time_s": 3.191, + "density_at_boot": 209, + "timestamp": 1773033672.6431203, + "vms_running": 209, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.619369506835938, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 209, + "firecracker_rss_mb": 9805.75390625, + "fc_socket_count": 209, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 210, + "boot_time_s": 2.493, + "density_at_boot": 210, + "timestamp": 1773033675.3110383, + "vms_running": 210, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.677513122558594, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 210, + "firecracker_rss_mb": 9852.9375, + "fc_socket_count": 210, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 211, + "boot_time_s": 3.235, + "density_at_boot": 211, + "timestamp": 1773033678.7220268, + "vms_running": 211, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.724494934082031, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 211, + "firecracker_rss_mb": 9900.1171875, + "fc_socket_count": 211, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 212, + "boot_time_s": 3.18, + "density_at_boot": 212, + "timestamp": 1773033682.0824926, + "vms_running": 212, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.762870788574219, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 212, + "firecracker_rss_mb": 9946.78125, + "fc_socket_count": 212, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 213, + "boot_time_s": 3.265, + "density_at_boot": 213, + "timestamp": 1773033685.5220332, + "vms_running": 213, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.811355590820312, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 213, + "firecracker_rss_mb": 9993.70703125, + "fc_socket_count": 213, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 214, + "boot_time_s": 2.224, + "density_at_boot": 214, + "timestamp": 1773033687.9207778, + "vms_running": 214, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.849857330322266, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 214, + "firecracker_rss_mb": 10040.37890625, + "fc_socket_count": 214, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 215, + "boot_time_s": 3.185, + "density_at_boot": 215, + "timestamp": 1773033691.2841442, + "vms_running": 215, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.905830383300781, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 215, + "firecracker_rss_mb": 10087.30859375, + "fc_socket_count": 215, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 216, + "boot_time_s": 2.32, + "density_at_boot": 216, + "timestamp": 1773033693.7820256, + "vms_running": 216, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.955081939697266, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 216, + "firecracker_rss_mb": 10133.72265625, + "fc_socket_count": 216, + "sqlite_db_kb": 256.0 + }, + { + "event": "boot_ok", + "vm_seq": 217, + "boot_time_s": 3.163, + "density_at_boot": 217, + "timestamp": 1773033697.1216776, + "vms_running": 217, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.997241973876953, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 217, + "firecracker_rss_mb": 10180.6484375, + "fc_socket_count": 217, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 218, + "boot_time_s": 3.265, + "density_at_boot": 218, + "timestamp": 1773033700.5650856, + "vms_running": 218, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.045398712158203, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 218, + "firecracker_rss_mb": 10227.83203125, + "fc_socket_count": 218, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 219, + "boot_time_s": 2.279, + "density_at_boot": 219, + "timestamp": 1773033703.022103, + "vms_running": 219, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.093620300292969, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 219, + "firecracker_rss_mb": 10275.2734375, + "fc_socket_count": 219, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 220, + "boot_time_s": 2.433, + "density_at_boot": 220, + "timestamp": 1773033705.6311026, + "vms_running": 220, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.141223907470703, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 220, + "firecracker_rss_mb": 10322.19921875, + "fc_socket_count": 220, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 221, + "boot_time_s": 3.156, + "density_at_boot": 221, + "timestamp": 1773033708.9627576, + "vms_running": 221, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.182518005371094, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 221, + "firecracker_rss_mb": 10368.8671875, + "fc_socket_count": 221, + "sqlite_db_kb": 272.0 + }, + { + "event": "boot_ok", + "vm_seq": 222, + "boot_time_s": 2.405, + "density_at_boot": 222, + "timestamp": 1773033711.541123, + "vms_running": 222, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.22659683227539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 222, + "firecracker_rss_mb": 10415.53515625, + "fc_socket_count": 222, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 223, + "boot_time_s": 2.305, + "density_at_boot": 223, + "timestamp": 1773033714.0210059, + "vms_running": 223, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.278278350830078, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 223, + "firecracker_rss_mb": 10462.4609375, + "fc_socket_count": 223, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 224, + "boot_time_s": 3.239, + "density_at_boot": 224, + "timestamp": 1773033717.4414132, + "vms_running": 224, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.334373474121094, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 224, + "firecracker_rss_mb": 10509.1328125, + "fc_socket_count": 224, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 225, + "boot_time_s": 2.319, + "density_at_boot": 225, + "timestamp": 1773033719.9409328, + "vms_running": 225, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.38070297241211, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 225, + "firecracker_rss_mb": 10555.8046875, + "fc_socket_count": 225, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 226, + "boot_time_s": 3.323, + "density_at_boot": 226, + "timestamp": 1773033723.4444726, + "vms_running": 226, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.42630386352539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 226, + "firecracker_rss_mb": 10602.7265625, + "fc_socket_count": 226, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 227, + "boot_time_s": 3.176, + "density_at_boot": 227, + "timestamp": 1773033726.8020544, + "vms_running": 227, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.469928741455078, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 227, + "firecracker_rss_mb": 10649.390625, + "fc_socket_count": 227, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 228, + "boot_time_s": 3.187, + "density_at_boot": 228, + "timestamp": 1773033730.1644514, + "vms_running": 228, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.523738861083984, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 228, + "firecracker_rss_mb": 10696.3203125, + "fc_socket_count": 228, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 229, + "boot_time_s": 3.262, + "density_at_boot": 229, + "timestamp": 1773033733.6042023, + "vms_running": 229, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.56546401977539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 229, + "firecracker_rss_mb": 10743.50390625, + "fc_socket_count": 229, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 230, + "boot_time_s": 3.259, + "density_at_boot": 230, + "timestamp": 1773033737.0411217, + "vms_running": 230, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.606185913085938, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 230, + "firecracker_rss_mb": 10790.16796875, + "fc_socket_count": 230, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 231, + "boot_time_s": 3.261, + "density_at_boot": 231, + "timestamp": 1773033740.4821775, + "vms_running": 231, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.671470642089844, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 231, + "firecracker_rss_mb": 10837.09765625, + "fc_socket_count": 231, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 232, + "boot_time_s": 3.175, + "density_at_boot": 232, + "timestamp": 1773033743.8407533, + "vms_running": 232, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.712615966796875, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 232, + "firecracker_rss_mb": 10884.0234375, + "fc_socket_count": 232, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 233, + "boot_time_s": 3.221, + "density_at_boot": 233, + "timestamp": 1773033747.2403154, + "vms_running": 233, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.756458282470703, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 233, + "firecracker_rss_mb": 10930.94921875, + "fc_socket_count": 233, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 234, + "boot_time_s": 2.28, + "density_at_boot": 234, + "timestamp": 1773033749.7022865, + "vms_running": 234, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.799877166748047, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 234, + "firecracker_rss_mb": 10978.13671875, + "fc_socket_count": 234, + "sqlite_db_kb": 324.0 + }, + { + "event": "boot_ok", + "vm_seq": 235, + "boot_time_s": 3.32, + "density_at_boot": 235, + "timestamp": 1773033753.2051058, + "vms_running": 235, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.846595764160156, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 235, + "firecracker_rss_mb": 11024.80859375, + "fc_socket_count": 235, + "sqlite_db_kb": 324.0 + }, + { + "event": "boot_ok", + "vm_seq": 236, + "boot_time_s": 3.259, + "density_at_boot": 236, + "timestamp": 1773033756.6450055, + "vms_running": 236, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.88980484008789, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 236, + "firecracker_rss_mb": 11071.734375, + "fc_socket_count": 236, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 237, + "boot_time_s": 3.262, + "density_at_boot": 237, + "timestamp": 1773033760.0850143, + "vms_running": 237, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.9407958984375, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 237, + "firecracker_rss_mb": 11118.40234375, + "fc_socket_count": 237, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 238, + "boot_time_s": 3.258, + "density_at_boot": 238, + "timestamp": 1773033763.5224333, + "vms_running": 238, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.986568450927734, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 238, + "firecracker_rss_mb": 11165.5859375, + "fc_socket_count": 238, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 239, + "boot_time_s": 3.257, + "density_at_boot": 239, + "timestamp": 1773033766.9620733, + "vms_running": 239, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.035202026367188, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 239, + "firecracker_rss_mb": 11212.25390625, + "fc_socket_count": 239, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 240, + "boot_time_s": 3.34, + "density_at_boot": 240, + "timestamp": 1773033770.482531, + "vms_running": 240, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.085208892822266, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 240, + "firecracker_rss_mb": 11259.18359375, + "fc_socket_count": 240, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 241, + "boot_time_s": 2.274, + "density_at_boot": 241, + "timestamp": 1773033772.939943, + "vms_running": 241, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.136260986328125, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 241, + "firecracker_rss_mb": 11305.6015625, + "fc_socket_count": 241, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 242, + "boot_time_s": 3.284, + "density_at_boot": 242, + "timestamp": 1773033776.4048007, + "vms_running": 242, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 14.17977523803711, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 242, + "firecracker_rss_mb": 11352.2734375, + "fc_socket_count": 242, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 243, + "boot_time_s": 2.318, + "density_at_boot": 243, + "timestamp": 1773033778.9048815, + "vms_running": 243, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 14.225570678710938, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 243, + "firecracker_rss_mb": 11399.97265625, + "fc_socket_count": 243, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 244, + "boot_time_s": 3.241, + "density_at_boot": 244, + "timestamp": 1773033782.3236187, + "vms_running": 244, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.274162292480469, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 244, + "firecracker_rss_mb": 11446.90234375, + "fc_socket_count": 244, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 245, + "boot_time_s": 3.412, + "density_at_boot": 245, + "timestamp": 1773033785.9220474, + "vms_running": 245, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.318473815917969, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 245, + "firecracker_rss_mb": 11493.3125, + "fc_socket_count": 245, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 246, + "boot_time_s": 3.255, + "density_at_boot": 246, + "timestamp": 1773033789.3639004, + "vms_running": 246, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.37160873413086, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 246, + "firecracker_rss_mb": 11539.7265625, + "fc_socket_count": 246, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 247, + "boot_time_s": 3.259, + "density_at_boot": 247, + "timestamp": 1773033792.8039594, + "vms_running": 247, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 14.427932739257812, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 247, + "firecracker_rss_mb": 11586.65234375, + "fc_socket_count": 247, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 248, + "boot_time_s": 3.26, + "density_at_boot": 248, + "timestamp": 1773033796.244873, + "vms_running": 248, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.464420318603516, + "host_disk_used_gb": 2.074138641357422, + "tap_count": 248, + "firecracker_rss_mb": 11633.32421875, + "fc_socket_count": 248, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 249, + "boot_time_s": 3.26, + "density_at_boot": 249, + "timestamp": 1773033799.6849911, + "vms_running": 249, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.509002685546875, + "host_disk_used_gb": 2.074169158935547, + "tap_count": 249, + "firecracker_rss_mb": 11680.25, + "fc_socket_count": 249, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 250, + "boot_time_s": 3.131, + "density_at_boot": 250, + "timestamp": 1773033803.0008395, + "vms_running": 250, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.562793731689453, + "host_disk_used_gb": 2.074230194091797, + "tap_count": 250, + "firecracker_rss_mb": 11727.43359375, + "fc_socket_count": 250, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 251, + "boot_time_s": 3.217, + "density_at_boot": 251, + "timestamp": 1773033806.4029758, + "vms_running": 251, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.611839294433594, + "host_disk_used_gb": 2.0742530822753906, + "tap_count": 251, + "firecracker_rss_mb": 11774.62109375, + "fc_socket_count": 251, + "sqlite_db_kb": 340.0 + }, + { + "event": "boot_ok", + "vm_seq": 252, + "boot_time_s": 3.417, + "density_at_boot": 252, + "timestamp": 1773033810.0056808, + "vms_running": 252, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.651336669921875, + "host_disk_used_gb": 2.0743331909179688, + "tap_count": 252, + "firecracker_rss_mb": 11822.0625, + "fc_socket_count": 252, + "sqlite_db_kb": 340.0 + }, + { + "event": "boot_ok", + "vm_seq": 253, + "boot_time_s": 3.25, + "density_at_boot": 253, + "timestamp": 1773033813.440772, + "vms_running": 253, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.702342987060547, + "host_disk_used_gb": 2.0743141174316406, + "tap_count": 253, + "firecracker_rss_mb": 11868.73046875, + "fc_socket_count": 253, + "sqlite_db_kb": 340.0 + }, + { + "event": "sustain_check", + "sustain_sec": 60, + "vms_alive": 253, + "vms_dead": [], + "vms_checked": 253, + "timestamp": 1773033874.0488198, + "vms_running": 253, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.580455780029297, + "host_disk_used_gb": 2.074298858642578, + "tap_count": 253, + "firecracker_rss_mb": 11942.98046875, + "fc_socket_count": 253, + "sqlite_db_kb": 340.0 + }, + { + "event": "teardown", + "teardown_time_s": 127.52, + "timestamp": 1773034001.7450569, + "vms_running": 0, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0937042236328125, + "host_disk_used_gb": 2.0742874145507812, + "tap_count": 253, + "firecracker_rss_mb": 0.0, + "fc_socket_count": 0, + "sqlite_db_kb": 340.0 + } +] \ No newline at end of file From 0645b604c911d08dcf6f1163b1a89997622335ad Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 01:41:56 -0400 Subject: [PATCH 12/20] add GCP density ramp script and re-tested results Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/density_20260309_010721.json | 3830 +++++++++++++++++++++++ benchmarks/run_density_ramp_gcp.sh | 286 ++ 2 files changed, 4116 insertions(+) create mode 100644 benchmarks/density_20260309_010721.json create mode 100755 benchmarks/run_density_ramp_gcp.sh diff --git a/benchmarks/density_20260309_010721.json b/benchmarks/density_20260309_010721.json new file mode 100644 index 0000000..b5497cf --- /dev/null +++ b/benchmarks/density_20260309_010721.json @@ -0,0 +1,3830 @@ +[ + { + "event": "meta", + "note": "re-tested after rebase" + }, + { + "event": "boot_ok", + "vm_seq": 1, + "boot_time_s": 3.557, + "density_at_boot": 1, + "timestamp": 1773033027.8439739, + "vms_running": 1, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.7269515991210938, + "host_disk_used_gb": 2.0351943969726562, + "tap_count": 1, + "firecracker_rss_mb": 47.4375, + "fc_socket_count": 1, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 2, + "boot_time_s": 3.012, + "density_at_boot": 2, + "timestamp": 1773033031.0415125, + "vms_running": 2, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 2.7830047607421875, + "host_disk_used_gb": 2.0351943969726562, + "tap_count": 2, + "firecracker_rss_mb": 94.62109375, + "fc_socket_count": 2, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 3, + "boot_time_s": 2.976, + "density_at_boot": 3, + "timestamp": 1773033034.1608803, + "vms_running": 3, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 2.8303489685058594, + "host_disk_used_gb": 2.0352554321289062, + "tap_count": 3, + "firecracker_rss_mb": 141.55078125, + "fc_socket_count": 3, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 4, + "boot_time_s": 3.058, + "density_at_boot": 4, + "timestamp": 1773033037.361834, + "vms_running": 4, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.877735137939453, + "host_disk_used_gb": 2.0352554321289062, + "tap_count": 4, + "firecracker_rss_mb": 188.73828125, + "fc_socket_count": 4, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 5, + "boot_time_s": 3.218, + "density_at_boot": 5, + "timestamp": 1773033040.722996, + "vms_running": 5, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.936298370361328, + "host_disk_used_gb": 2.0353164672851562, + "tap_count": 5, + "firecracker_rss_mb": 235.14453125, + "fc_socket_count": 5, + "sqlite_db_kb": 52.0 + }, + { + "event": "boot_ok", + "vm_seq": 6, + "boot_time_s": 2.977, + "density_at_boot": 6, + "timestamp": 1773033043.8448167, + "vms_running": 6, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 2.993610382080078, + "host_disk_used_gb": 2.0353164672851562, + "tap_count": 6, + "firecracker_rss_mb": 282.84765625, + "fc_socket_count": 6, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 7, + "boot_time_s": 2.973, + "density_at_boot": 7, + "timestamp": 1773033046.962404, + "vms_running": 7, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0497703552246094, + "host_disk_used_gb": 2.0353775024414062, + "tap_count": 7, + "firecracker_rss_mb": 330.29296875, + "fc_socket_count": 7, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 8, + "boot_time_s": 2.117, + "density_at_boot": 8, + "timestamp": 1773033049.2229445, + "vms_running": 8, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.100330352783203, + "host_disk_used_gb": 2.0353775024414062, + "tap_count": 8, + "firecracker_rss_mb": 377.22265625, + "fc_socket_count": 8, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 9, + "boot_time_s": 3.035, + "density_at_boot": 9, + "timestamp": 1773033052.4030461, + "vms_running": 9, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.1607666015625, + "host_disk_used_gb": 2.0354385375976562, + "tap_count": 9, + "firecracker_rss_mb": 424.40625, + "fc_socket_count": 9, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 10, + "boot_time_s": 3.054, + "density_at_boot": 10, + "timestamp": 1773033055.6033888, + "vms_running": 10, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.2168922424316406, + "host_disk_used_gb": 2.0354385375976562, + "tap_count": 10, + "firecracker_rss_mb": 470.81640625, + "fc_socket_count": 10, + "sqlite_db_kb": 60.0 + }, + { + "event": "boot_ok", + "vm_seq": 11, + "boot_time_s": 2.973, + "density_at_boot": 11, + "timestamp": 1773033058.7229776, + "vms_running": 11, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.2730178833007812, + "host_disk_used_gb": 2.0354995727539062, + "tap_count": 11, + "firecracker_rss_mb": 517.48046875, + "fc_socket_count": 11, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 12, + "boot_time_s": 2.97, + "density_at_boot": 12, + "timestamp": 1773033061.8406522, + "vms_running": 12, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.3240890502929688, + "host_disk_used_gb": 2.0354995727539062, + "tap_count": 12, + "firecracker_rss_mb": 564.671875, + "fc_socket_count": 12, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 13, + "boot_time_s": 2.975, + "density_at_boot": 13, + "timestamp": 1773033064.9625804, + "vms_running": 13, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.38525390625, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 13, + "firecracker_rss_mb": 612.37109375, + "fc_socket_count": 13, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 14, + "boot_time_s": 2.053, + "density_at_boot": 14, + "timestamp": 1773033067.1609247, + "vms_running": 14, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.4327239990234375, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 14, + "firecracker_rss_mb": 660.078125, + "fc_socket_count": 14, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 15, + "boot_time_s": 2.075, + "density_at_boot": 15, + "timestamp": 1773033069.3810976, + "vms_running": 15, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.485340118408203, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 15, + "firecracker_rss_mb": 707.0, + "fc_socket_count": 15, + "sqlite_db_kb": 64.0 + }, + { + "event": "boot_ok", + "vm_seq": 16, + "boot_time_s": 1.971, + "density_at_boot": 16, + "timestamp": 1773033071.4986103, + "vms_running": 16, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.5328598022460938, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 16, + "firecracker_rss_mb": 754.95703125, + "fc_socket_count": 16, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 17, + "boot_time_s": 2.139, + "density_at_boot": 17, + "timestamp": 1773033073.7816103, + "vms_running": 17, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.590251922607422, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 17, + "firecracker_rss_mb": 801.8828125, + "fc_socket_count": 17, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 18, + "boot_time_s": 2.993, + "density_at_boot": 18, + "timestamp": 1773033076.9206767, + "vms_running": 18, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.6424293518066406, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 18, + "firecracker_rss_mb": 848.80859375, + "fc_socket_count": 18, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 19, + "boot_time_s": 3.095, + "density_at_boot": 19, + "timestamp": 1773033080.1619146, + "vms_running": 19, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.6910667419433594, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 19, + "firecracker_rss_mb": 895.73828125, + "fc_socket_count": 19, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 20, + "boot_time_s": 2.93, + "density_at_boot": 20, + "timestamp": 1773033083.2386947, + "vms_running": 20, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 3.746997833251953, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 20, + "firecracker_rss_mb": 943.69921875, + "fc_socket_count": 20, + "sqlite_db_kb": 68.0 + }, + { + "event": "boot_ok", + "vm_seq": 21, + "boot_time_s": 2.239, + "density_at_boot": 21, + "timestamp": 1773033085.62172, + "vms_running": 21, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 3.7973709106445312, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 21, + "firecracker_rss_mb": 990.62890625, + "fc_socket_count": 21, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 22, + "boot_time_s": 3.034, + "density_at_boot": 22, + "timestamp": 1773033088.8028262, + "vms_running": 22, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 3.8506126403808594, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 22, + "firecracker_rss_mb": 1037.55078125, + "fc_socket_count": 22, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 23, + "boot_time_s": 2.17, + "density_at_boot": 23, + "timestamp": 1773033091.1226404, + "vms_running": 23, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.9020309448242188, + "host_disk_used_gb": 2.0359878540039062, + "tap_count": 23, + "firecracker_rss_mb": 1084.47265625, + "fc_socket_count": 23, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 24, + "boot_time_s": 3.054, + "density_at_boot": 24, + "timestamp": 1773033094.3238337, + "vms_running": 24, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.951507568359375, + "host_disk_used_gb": 2.0360107421875, + "tap_count": 24, + "firecracker_rss_mb": 1131.40234375, + "fc_socket_count": 24, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 25, + "boot_time_s": 3.051, + "density_at_boot": 25, + "timestamp": 1773033097.5225387, + "vms_running": 25, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.002567291259766, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 25, + "firecracker_rss_mb": 1178.328125, + "fc_socket_count": 25, + "sqlite_db_kb": 72.0 + }, + { + "event": "boot_ok", + "vm_seq": 26, + "boot_time_s": 2.231, + "density_at_boot": 26, + "timestamp": 1773033099.9013627, + "vms_running": 26, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.061363220214844, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 26, + "firecracker_rss_mb": 1225.76953125, + "fc_socket_count": 26, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 27, + "boot_time_s": 3.073, + "density_at_boot": 27, + "timestamp": 1773033103.1235607, + "vms_running": 27, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.113433837890625, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 27, + "firecracker_rss_mb": 1272.69921875, + "fc_socket_count": 27, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 28, + "boot_time_s": 3.128, + "density_at_boot": 28, + "timestamp": 1773033106.4006462, + "vms_running": 28, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.165180206298828, + "host_disk_used_gb": 2.035991668701172, + "tap_count": 28, + "firecracker_rss_mb": 1319.3671875, + "fc_socket_count": 28, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 29, + "boot_time_s": 3.056, + "density_at_boot": 29, + "timestamp": 1773033109.6045015, + "vms_running": 29, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.213230133056641, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 29, + "firecracker_rss_mb": 1366.80859375, + "fc_socket_count": 29, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 30, + "boot_time_s": 3.051, + "density_at_boot": 30, + "timestamp": 1773033112.804648, + "vms_running": 30, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.257366180419922, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 30, + "firecracker_rss_mb": 1413.48046875, + "fc_socket_count": 30, + "sqlite_db_kb": 76.0 + }, + { + "event": "boot_ok", + "vm_seq": 31, + "boot_time_s": 3.05, + "density_at_boot": 31, + "timestamp": 1773033116.0029683, + "vms_running": 31, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.305568695068359, + "host_disk_used_gb": 2.036968231201172, + "tap_count": 31, + "firecracker_rss_mb": 1460.40234375, + "fc_socket_count": 31, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 32, + "boot_time_s": 3.052, + "density_at_boot": 32, + "timestamp": 1773033119.2038808, + "vms_running": 32, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 4.353710174560547, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 32, + "firecracker_rss_mb": 1507.328125, + "fc_socket_count": 32, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 33, + "boot_time_s": 3.13, + "density_at_boot": 33, + "timestamp": 1773033122.4816763, + "vms_running": 33, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.400493621826172, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 33, + "firecracker_rss_mb": 1554.2578125, + "fc_socket_count": 33, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 34, + "boot_time_s": 3.006, + "density_at_boot": 34, + "timestamp": 1773033125.6367514, + "vms_running": 34, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 4.442150115966797, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 34, + "firecracker_rss_mb": 1601.703125, + "fc_socket_count": 34, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 35, + "boot_time_s": 3.019, + "density_at_boot": 35, + "timestamp": 1773033128.801706, + "vms_running": 35, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.484050750732422, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 35, + "firecracker_rss_mb": 1648.6328125, + "fc_socket_count": 35, + "sqlite_db_kb": 80.0 + }, + { + "event": "boot_ok", + "vm_seq": 36, + "boot_time_s": 3.05, + "density_at_boot": 36, + "timestamp": 1773033132.0019503, + "vms_running": 36, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.5365753173828125, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 36, + "firecracker_rss_mb": 1695.5625, + "fc_socket_count": 36, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 37, + "boot_time_s": 3.048, + "density_at_boot": 37, + "timestamp": 1773033135.201699, + "vms_running": 37, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.581813812255859, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 37, + "firecracker_rss_mb": 1742.7421875, + "fc_socket_count": 37, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 38, + "boot_time_s": 3.051, + "density_at_boot": 38, + "timestamp": 1773033138.4028268, + "vms_running": 38, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.623851776123047, + "host_disk_used_gb": 2.0369720458984375, + "tap_count": 38, + "firecracker_rss_mb": 1789.671875, + "fc_socket_count": 38, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 39, + "boot_time_s": 3.051, + "density_at_boot": 39, + "timestamp": 1773033141.6038764, + "vms_running": 39, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.667224884033203, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 39, + "firecracker_rss_mb": 1836.34375, + "fc_socket_count": 39, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 40, + "boot_time_s": 3.047, + "density_at_boot": 40, + "timestamp": 1773033144.8007727, + "vms_running": 40, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.7087860107421875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 40, + "firecracker_rss_mb": 1883.5234375, + "fc_socket_count": 40, + "sqlite_db_kb": 84.0 + }, + { + "event": "boot_ok", + "vm_seq": 41, + "boot_time_s": 3.051, + "density_at_boot": 41, + "timestamp": 1773033148.0039015, + "vms_running": 41, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 4.762592315673828, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 41, + "firecracker_rss_mb": 1930.19140625, + "fc_socket_count": 41, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 42, + "boot_time_s": 3.047, + "density_at_boot": 42, + "timestamp": 1773033151.2032633, + "vms_running": 42, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.809150695800781, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 42, + "firecracker_rss_mb": 1977.37890625, + "fc_socket_count": 42, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 43, + "boot_time_s": 3.048, + "density_at_boot": 43, + "timestamp": 1773033154.4018452, + "vms_running": 43, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.859760284423828, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 43, + "firecracker_rss_mb": 2024.8203125, + "fc_socket_count": 43, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 44, + "boot_time_s": 3.051, + "density_at_boot": 44, + "timestamp": 1773033157.601361, + "vms_running": 44, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.906074523925781, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 44, + "firecracker_rss_mb": 2071.4921875, + "fc_socket_count": 44, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 45, + "boot_time_s": 3.009, + "density_at_boot": 45, + "timestamp": 1773033160.7611601, + "vms_running": 45, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 4.957592010498047, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 45, + "firecracker_rss_mb": 2118.421875, + "fc_socket_count": 45, + "sqlite_db_kb": 88.0 + }, + { + "event": "boot_ok", + "vm_seq": 46, + "boot_time_s": 3.171, + "density_at_boot": 46, + "timestamp": 1773033164.0836096, + "vms_running": 46, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.002906799316406, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 46, + "firecracker_rss_mb": 2165.34765625, + "fc_socket_count": 46, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 47, + "boot_time_s": 3.046, + "density_at_boot": 47, + "timestamp": 1773033167.2820804, + "vms_running": 47, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.047607421875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 47, + "firecracker_rss_mb": 2212.53515625, + "fc_socket_count": 47, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 48, + "boot_time_s": 3.047, + "density_at_boot": 48, + "timestamp": 1773033170.4816763, + "vms_running": 48, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.085933685302734, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 48, + "firecracker_rss_mb": 2259.46484375, + "fc_socket_count": 48, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 49, + "boot_time_s": 3.128, + "density_at_boot": 49, + "timestamp": 1773033173.761677, + "vms_running": 49, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.1317138671875, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 49, + "firecracker_rss_mb": 2306.13671875, + "fc_socket_count": 49, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 50, + "boot_time_s": 3.05, + "density_at_boot": 50, + "timestamp": 1773033176.9637046, + "vms_running": 50, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.177833557128906, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 50, + "firecracker_rss_mb": 2353.83984375, + "fc_socket_count": 50, + "sqlite_db_kb": 92.0 + }, + { + "event": "boot_ok", + "vm_seq": 51, + "boot_time_s": 3.046, + "density_at_boot": 51, + "timestamp": 1773033180.1613538, + "vms_running": 51, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.221309661865234, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 51, + "firecracker_rss_mb": 2400.51171875, + "fc_socket_count": 51, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 52, + "boot_time_s": 3.05, + "density_at_boot": 52, + "timestamp": 1773033183.3628714, + "vms_running": 52, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 5.270954132080078, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 52, + "firecracker_rss_mb": 2447.18359375, + "fc_socket_count": 52, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 53, + "boot_time_s": 2.111, + "density_at_boot": 53, + "timestamp": 1773033185.6233401, + "vms_running": 53, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.3211517333984375, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 53, + "firecracker_rss_mb": 2494.11328125, + "fc_socket_count": 53, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 54, + "boot_time_s": 3.024, + "density_at_boot": 54, + "timestamp": 1773033188.8009796, + "vms_running": 54, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.3712005615234375, + "host_disk_used_gb": 2.0447845458984375, + "tap_count": 54, + "firecracker_rss_mb": 2541.296875, + "fc_socket_count": 54, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 55, + "boot_time_s": 3.133, + "density_at_boot": 55, + "timestamp": 1773033192.0828273, + "vms_running": 55, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.407588958740234, + "host_disk_used_gb": 2.0448074340820312, + "tap_count": 55, + "firecracker_rss_mb": 2587.96484375, + "fc_socket_count": 55, + "sqlite_db_kb": 96.0 + }, + { + "event": "boot_ok", + "vm_seq": 56, + "boot_time_s": 3.007, + "density_at_boot": 56, + "timestamp": 1773033195.2397757, + "vms_running": 56, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.461029052734375, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 56, + "firecracker_rss_mb": 2635.40625, + "fc_socket_count": 56, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 57, + "boot_time_s": 3.012, + "density_at_boot": 57, + "timestamp": 1773033198.4022074, + "vms_running": 57, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.516471862792969, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 57, + "firecracker_rss_mb": 2682.5859375, + "fc_socket_count": 57, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 58, + "boot_time_s": 2.065, + "density_at_boot": 58, + "timestamp": 1773033200.6183062, + "vms_running": 58, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 5.566684722900391, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 58, + "firecracker_rss_mb": 2730.546875, + "fc_socket_count": 58, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 59, + "boot_time_s": 2.995, + "density_at_boot": 59, + "timestamp": 1773033203.7625341, + "vms_running": 59, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.616291046142578, + "host_disk_used_gb": 2.0447463989257812, + "tap_count": 59, + "firecracker_rss_mb": 2777.98828125, + "fc_socket_count": 59, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 60, + "boot_time_s": 3.005, + "density_at_boot": 60, + "timestamp": 1773033206.9203105, + "vms_running": 60, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.656620025634766, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 60, + "firecracker_rss_mb": 2824.65234375, + "fc_socket_count": 60, + "sqlite_db_kb": 100.0 + }, + { + "event": "boot_ok", + "vm_seq": 61, + "boot_time_s": 2.968, + "density_at_boot": 61, + "timestamp": 1773033210.0405595, + "vms_running": 61, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.709175109863281, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 61, + "firecracker_rss_mb": 2871.06640625, + "fc_socket_count": 61, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 62, + "boot_time_s": 2.968, + "density_at_boot": 62, + "timestamp": 1773033213.160054, + "vms_running": 62, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.756771087646484, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 62, + "firecracker_rss_mb": 2917.48046875, + "fc_socket_count": 62, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 63, + "boot_time_s": 3.09, + "density_at_boot": 63, + "timestamp": 1773033216.403268, + "vms_running": 63, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.798877716064453, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 63, + "firecracker_rss_mb": 2964.92578125, + "fc_socket_count": 63, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 64, + "boot_time_s": 2.064, + "density_at_boot": 64, + "timestamp": 1773033218.6201143, + "vms_running": 64, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 5.846565246582031, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 64, + "firecracker_rss_mb": 3012.11328125, + "fc_socket_count": 64, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 65, + "boot_time_s": 2.039, + "density_at_boot": 65, + "timestamp": 1773033220.8116317, + "vms_running": 65, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.889556884765625, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 65, + "firecracker_rss_mb": 3058.78515625, + "fc_socket_count": 65, + "sqlite_db_kb": 112.0 + }, + { + "event": "boot_ok", + "vm_seq": 66, + "boot_time_s": 3.036, + "density_at_boot": 66, + "timestamp": 1773033224.000127, + "vms_running": 66, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 5.9334716796875, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 66, + "firecracker_rss_mb": 3105.72265625, + "fc_socket_count": 66, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 67, + "boot_time_s": 2.274, + "density_at_boot": 67, + "timestamp": 1773033226.4246364, + "vms_running": 67, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 5.988681793212891, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 67, + "firecracker_rss_mb": 3152.6484375, + "fc_socket_count": 67, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 68, + "boot_time_s": 3.103, + "density_at_boot": 68, + "timestamp": 1773033229.6829405, + "vms_running": 68, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 6.028797149658203, + "host_disk_used_gb": 2.0466995239257812, + "tap_count": 68, + "firecracker_rss_mb": 3199.83203125, + "fc_socket_count": 68, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 69, + "boot_time_s": 3.05, + "density_at_boot": 69, + "timestamp": 1773033232.883963, + "vms_running": 69, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.079540252685547, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 69, + "firecracker_rss_mb": 3247.015625, + "fc_socket_count": 69, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 70, + "boot_time_s": 3.047, + "density_at_boot": 70, + "timestamp": 1773033236.083304, + "vms_running": 70, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.1288909912109375, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 70, + "firecracker_rss_mb": 3293.94140625, + "fc_socket_count": 70, + "sqlite_db_kb": 116.0 + }, + { + "event": "boot_ok", + "vm_seq": 71, + "boot_time_s": 3.045, + "density_at_boot": 71, + "timestamp": 1773033239.2812428, + "vms_running": 71, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.164848327636719, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 71, + "firecracker_rss_mb": 3340.8671875, + "fc_socket_count": 71, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 72, + "boot_time_s": 3.007, + "density_at_boot": 72, + "timestamp": 1773033242.4412746, + "vms_running": 72, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.211551666259766, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 72, + "firecracker_rss_mb": 3388.05078125, + "fc_socket_count": 72, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 73, + "boot_time_s": 3.088, + "density_at_boot": 73, + "timestamp": 1773033245.683507, + "vms_running": 73, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.2582550048828125, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 73, + "firecracker_rss_mb": 3435.23828125, + "fc_socket_count": 73, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 74, + "boot_time_s": 2.142, + "density_at_boot": 74, + "timestamp": 1773033247.978695, + "vms_running": 74, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.303688049316406, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 74, + "firecracker_rss_mb": 3481.90625, + "fc_socket_count": 74, + "sqlite_db_kb": 120.0 + }, + { + "event": "boot_ok", + "vm_seq": 75, + "boot_time_s": 2.031, + "density_at_boot": 75, + "timestamp": 1773033250.163482, + "vms_running": 75, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.348236083984375, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 75, + "firecracker_rss_mb": 3528.8359375, + "fc_socket_count": 75, + "sqlite_db_kb": 128.0 + }, + { + "event": "boot_ok", + "vm_seq": 76, + "boot_time_s": 2.186, + "density_at_boot": 76, + "timestamp": 1773033252.5023098, + "vms_running": 76, + "host_cpu_pct": 0.5, + "host_mem_used_gb": 6.395847320556641, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 76, + "firecracker_rss_mb": 3576.01953125, + "fc_socket_count": 76, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 77, + "boot_time_s": 3.112, + "density_at_boot": 77, + "timestamp": 1773033255.7646894, + "vms_running": 77, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.447135925292969, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 77, + "firecracker_rss_mb": 3622.69140625, + "fc_socket_count": 77, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 78, + "boot_time_s": 2.997, + "density_at_boot": 78, + "timestamp": 1773033258.9184716, + "vms_running": 78, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 6.4872283935546875, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 78, + "firecracker_rss_mb": 3670.39453125, + "fc_socket_count": 78, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 79, + "boot_time_s": 3.011, + "density_at_boot": 79, + "timestamp": 1773033262.0819917, + "vms_running": 79, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.534366607666016, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 79, + "firecracker_rss_mb": 3717.3203125, + "fc_socket_count": 79, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 80, + "boot_time_s": 3.082, + "density_at_boot": 80, + "timestamp": 1773033265.3196058, + "vms_running": 80, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.580863952636719, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 80, + "firecracker_rss_mb": 3763.73046875, + "fc_socket_count": 80, + "sqlite_db_kb": 132.0 + }, + { + "event": "boot_ok", + "vm_seq": 81, + "boot_time_s": 2.965, + "density_at_boot": 81, + "timestamp": 1773033268.439817, + "vms_running": 81, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.624134063720703, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 81, + "firecracker_rss_mb": 3810.14453125, + "fc_socket_count": 81, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 82, + "boot_time_s": 3.007, + "density_at_boot": 82, + "timestamp": 1773033271.6033342, + "vms_running": 82, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 6.6730499267578125, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 82, + "firecracker_rss_mb": 3856.5546875, + "fc_socket_count": 82, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 83, + "boot_time_s": 2.999, + "density_at_boot": 83, + "timestamp": 1773033274.7591214, + "vms_running": 83, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.721355438232422, + "host_disk_used_gb": 2.045482635498047, + "tap_count": 83, + "firecracker_rss_mb": 3902.96875, + "fc_socket_count": 83, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 84, + "boot_time_s": 3.009, + "density_at_boot": 84, + "timestamp": 1773033277.9239209, + "vms_running": 84, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.7634429931640625, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 84, + "firecracker_rss_mb": 3950.15234375, + "fc_socket_count": 84, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 85, + "boot_time_s": 3.122, + "density_at_boot": 85, + "timestamp": 1773033281.2036185, + "vms_running": 85, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 6.805477142333984, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 85, + "firecracker_rss_mb": 3996.56640625, + "fc_socket_count": 85, + "sqlite_db_kb": 136.0 + }, + { + "event": "boot_ok", + "vm_seq": 86, + "boot_time_s": 3.124, + "density_at_boot": 86, + "timestamp": 1773033284.4832091, + "vms_running": 86, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 6.858394622802734, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 86, + "firecracker_rss_mb": 4042.98046875, + "fc_socket_count": 86, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 87, + "boot_time_s": 2.996, + "density_at_boot": 87, + "timestamp": 1773033287.63918, + "vms_running": 87, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 6.907325744628906, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 87, + "firecracker_rss_mb": 4090.42578125, + "fc_socket_count": 87, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 88, + "boot_time_s": 3.25, + "density_at_boot": 88, + "timestamp": 1773033291.0429933, + "vms_running": 88, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 6.96649169921875, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 88, + "firecracker_rss_mb": 4136.8359375, + "fc_socket_count": 88, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 89, + "boot_time_s": 3.04, + "density_at_boot": 89, + "timestamp": 1773033294.2414389, + "vms_running": 89, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.016696929931641, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 89, + "firecracker_rss_mb": 4184.28125, + "fc_socket_count": 89, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 90, + "boot_time_s": 3.127, + "density_at_boot": 90, + "timestamp": 1773033297.5242565, + "vms_running": 90, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.061672210693359, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 90, + "firecracker_rss_mb": 4230.953125, + "fc_socket_count": 90, + "sqlite_db_kb": 140.0 + }, + { + "event": "boot_ok", + "vm_seq": 91, + "boot_time_s": 3.121, + "density_at_boot": 91, + "timestamp": 1773033300.8026967, + "vms_running": 91, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.102863311767578, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 91, + "firecracker_rss_mb": 4278.13671875, + "fc_socket_count": 91, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 92, + "boot_time_s": 3.125, + "density_at_boot": 92, + "timestamp": 1773033304.0850515, + "vms_running": 92, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.147693634033203, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 92, + "firecracker_rss_mb": 4325.83984375, + "fc_socket_count": 92, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 93, + "boot_time_s": 2.18, + "density_at_boot": 93, + "timestamp": 1773033306.4212089, + "vms_running": 93, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.193912506103516, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 93, + "firecracker_rss_mb": 4372.25, + "fc_socket_count": 93, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 94, + "boot_time_s": 3.104, + "density_at_boot": 94, + "timestamp": 1773033309.6850111, + "vms_running": 94, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.243099212646484, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 94, + "firecracker_rss_mb": 4418.40625, + "fc_socket_count": 94, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 95, + "boot_time_s": 2.189, + "density_at_boot": 95, + "timestamp": 1773033312.0331566, + "vms_running": 95, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.286735534667969, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 95, + "firecracker_rss_mb": 4465.3359375, + "fc_socket_count": 95, + "sqlite_db_kb": 144.0 + }, + { + "event": "boot_ok", + "vm_seq": 96, + "boot_time_s": 3.088, + "density_at_boot": 96, + "timestamp": 1773033315.280903, + "vms_running": 96, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.325340270996094, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 96, + "firecracker_rss_mb": 4512.265625, + "fc_socket_count": 96, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 97, + "boot_time_s": 3.044, + "density_at_boot": 97, + "timestamp": 1773033318.4851127, + "vms_running": 97, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.373432159423828, + "host_disk_used_gb": 2.046703338623047, + "tap_count": 97, + "firecracker_rss_mb": 4559.19921875, + "fc_socket_count": 97, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 98, + "boot_time_s": 3.04, + "density_at_boot": 98, + "timestamp": 1773033321.6831727, + "vms_running": 98, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.423236846923828, + "host_disk_used_gb": 2.0467262268066406, + "tap_count": 98, + "firecracker_rss_mb": 4606.38671875, + "fc_socket_count": 98, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 99, + "boot_time_s": 3.124, + "density_at_boot": 99, + "timestamp": 1773033324.964652, + "vms_running": 99, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.467609405517578, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 99, + "firecracker_rss_mb": 4653.05859375, + "fc_socket_count": 99, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 100, + "boot_time_s": 3.122, + "density_at_boot": 100, + "timestamp": 1773033328.2430675, + "vms_running": 100, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.511039733886719, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 100, + "firecracker_rss_mb": 4699.46875, + "fc_socket_count": 100, + "sqlite_db_kb": 148.0 + }, + { + "event": "boot_ok", + "vm_seq": 101, + "boot_time_s": 3.127, + "density_at_boot": 101, + "timestamp": 1773033331.522668, + "vms_running": 101, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.559967041015625, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 101, + "firecracker_rss_mb": 4746.3984375, + "fc_socket_count": 101, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 102, + "boot_time_s": 2.18, + "density_at_boot": 102, + "timestamp": 1773033333.8610601, + "vms_running": 102, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 7.608421325683594, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 102, + "firecracker_rss_mb": 4793.0703125, + "fc_socket_count": 102, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 103, + "boot_time_s": 3.025, + "density_at_boot": 103, + "timestamp": 1773033337.0418603, + "vms_running": 103, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.656368255615234, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 103, + "firecracker_rss_mb": 4840.76953125, + "fc_socket_count": 103, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 104, + "boot_time_s": 2.184, + "density_at_boot": 104, + "timestamp": 1773033339.383744, + "vms_running": 104, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 7.709503173828125, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 104, + "firecracker_rss_mb": 4887.95703125, + "fc_socket_count": 104, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 105, + "boot_time_s": 3.184, + "density_at_boot": 105, + "timestamp": 1773033342.721289, + "vms_running": 105, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 7.748188018798828, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 105, + "firecracker_rss_mb": 4934.625, + "fc_socket_count": 105, + "sqlite_db_kb": 152.0 + }, + { + "event": "boot_ok", + "vm_seq": 106, + "boot_time_s": 3.08, + "density_at_boot": 106, + "timestamp": 1773033345.959677, + "vms_running": 106, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.791416168212891, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 106, + "firecracker_rss_mb": 4982.06640625, + "fc_socket_count": 106, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 107, + "boot_time_s": 2.106, + "density_at_boot": 107, + "timestamp": 1773033348.2202184, + "vms_running": 107, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 7.840679168701172, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 107, + "firecracker_rss_mb": 5028.4765625, + "fc_socket_count": 107, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 108, + "boot_time_s": 3.064, + "density_at_boot": 108, + "timestamp": 1773033351.4419806, + "vms_running": 108, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.8821258544921875, + "host_disk_used_gb": 2.0467071533203125, + "tap_count": 108, + "firecracker_rss_mb": 5075.40234375, + "fc_socket_count": 108, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 109, + "boot_time_s": 3.285, + "density_at_boot": 109, + "timestamp": 1773033354.881558, + "vms_running": 109, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.931728363037109, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 109, + "firecracker_rss_mb": 5122.328125, + "fc_socket_count": 109, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 110, + "boot_time_s": 2.181, + "density_at_boot": 110, + "timestamp": 1773033357.2215796, + "vms_running": 110, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 7.985015869140625, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 110, + "firecracker_rss_mb": 5169.25, + "fc_socket_count": 110, + "sqlite_db_kb": 156.0 + }, + { + "event": "boot_ok", + "vm_seq": 111, + "boot_time_s": 3.026, + "density_at_boot": 111, + "timestamp": 1773033360.4034083, + "vms_running": 111, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.026233673095703, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 111, + "firecracker_rss_mb": 5215.921875, + "fc_socket_count": 111, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 112, + "boot_time_s": 3.039, + "density_at_boot": 112, + "timestamp": 1773033363.60248, + "vms_running": 112, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.06964111328125, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 112, + "firecracker_rss_mb": 5262.58984375, + "fc_socket_count": 112, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 113, + "boot_time_s": 3.121, + "density_at_boot": 113, + "timestamp": 1773033366.8814447, + "vms_running": 113, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.123348236083984, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 113, + "firecracker_rss_mb": 5309.26171875, + "fc_socket_count": 113, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 114, + "boot_time_s": 3.135, + "density_at_boot": 114, + "timestamp": 1773033370.1746638, + "vms_running": 114, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.168418884277344, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 114, + "firecracker_rss_mb": 5356.19140625, + "fc_socket_count": 114, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 115, + "boot_time_s": 3.112, + "density_at_boot": 115, + "timestamp": 1773033373.4441922, + "vms_running": 115, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.210132598876953, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 115, + "firecracker_rss_mb": 5403.37890625, + "fc_socket_count": 115, + "sqlite_db_kb": 160.0 + }, + { + "event": "boot_ok", + "vm_seq": 116, + "boot_time_s": 3.121, + "density_at_boot": 116, + "timestamp": 1773033376.7231078, + "vms_running": 116, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.251083374023438, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 116, + "firecracker_rss_mb": 5450.046875, + "fc_socket_count": 116, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 117, + "boot_time_s": 3.122, + "density_at_boot": 117, + "timestamp": 1773033380.0035434, + "vms_running": 117, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.304367065429688, + "host_disk_used_gb": 2.0467300415039062, + "tap_count": 117, + "firecracker_rss_mb": 5496.9765625, + "fc_socket_count": 117, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 118, + "boot_time_s": 3.202, + "density_at_boot": 118, + "timestamp": 1773033383.3633437, + "vms_running": 118, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.354461669921875, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 118, + "firecracker_rss_mb": 5543.8984375, + "fc_socket_count": 118, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 119, + "boot_time_s": 3.117, + "density_at_boot": 119, + "timestamp": 1773033386.6418316, + "vms_running": 119, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.395759582519531, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 119, + "firecracker_rss_mb": 5590.56640625, + "fc_socket_count": 119, + "sqlite_db_kb": 164.0 + }, + { + "event": "boot_ok", + "vm_seq": 120, + "boot_time_s": 3.123, + "density_at_boot": 120, + "timestamp": 1773033389.9224994, + "vms_running": 120, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.447036743164062, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 120, + "firecracker_rss_mb": 5636.97265625, + "fc_socket_count": 120, + "sqlite_db_kb": 168.0 + }, + { + "event": "boot_ok", + "vm_seq": 121, + "boot_time_s": 3.076, + "density_at_boot": 121, + "timestamp": 1773033393.1599932, + "vms_running": 121, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.49530029296875, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 121, + "firecracker_rss_mb": 5684.15234375, + "fc_socket_count": 121, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 122, + "boot_time_s": 3.082, + "density_at_boot": 122, + "timestamp": 1773033396.4016879, + "vms_running": 122, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.541004180908203, + "host_disk_used_gb": 2.046710968017578, + "tap_count": 122, + "firecracker_rss_mb": 5731.33984375, + "fc_socket_count": 122, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 123, + "boot_time_s": 3.04, + "density_at_boot": 123, + "timestamp": 1773033399.601394, + "vms_running": 123, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.587997436523438, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 123, + "firecracker_rss_mb": 5778.00390625, + "fc_socket_count": 123, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 124, + "boot_time_s": 3.201, + "density_at_boot": 124, + "timestamp": 1773033402.96306, + "vms_running": 124, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.630805969238281, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 124, + "firecracker_rss_mb": 5824.671875, + "fc_socket_count": 124, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 125, + "boot_time_s": 3.117, + "density_at_boot": 125, + "timestamp": 1773033406.2411644, + "vms_running": 125, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.680839538574219, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 125, + "firecracker_rss_mb": 5871.0859375, + "fc_socket_count": 125, + "sqlite_db_kb": 172.0 + }, + { + "event": "boot_ok", + "vm_seq": 126, + "boot_time_s": 3.08, + "density_at_boot": 126, + "timestamp": 1773033409.4800408, + "vms_running": 126, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 8.728694915771484, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 126, + "firecracker_rss_mb": 5918.53125, + "fc_socket_count": 126, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 127, + "boot_time_s": 3.088, + "density_at_boot": 127, + "timestamp": 1773033412.7238917, + "vms_running": 127, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.772705078125, + "host_disk_used_gb": 2.048664093017578, + "tap_count": 127, + "firecracker_rss_mb": 5965.71484375, + "fc_socket_count": 127, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 128, + "boot_time_s": 3.117, + "density_at_boot": 128, + "timestamp": 1773033416.000301, + "vms_running": 128, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.832965850830078, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 128, + "firecracker_rss_mb": 6012.640625, + "fc_socket_count": 128, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 129, + "boot_time_s": 3.119, + "density_at_boot": 129, + "timestamp": 1773033419.281909, + "vms_running": 129, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 8.882610321044922, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 129, + "firecracker_rss_mb": 6059.56640625, + "fc_socket_count": 129, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 130, + "boot_time_s": 3.117, + "density_at_boot": 130, + "timestamp": 1773033422.562466, + "vms_running": 130, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 8.926074981689453, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 130, + "firecracker_rss_mb": 6107.0078125, + "fc_socket_count": 130, + "sqlite_db_kb": 176.0 + }, + { + "event": "boot_ok", + "vm_seq": 131, + "boot_time_s": 3.121, + "density_at_boot": 131, + "timestamp": 1773033425.844859, + "vms_running": 131, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 8.970325469970703, + "host_disk_used_gb": 2.0486679077148438, + "tap_count": 131, + "firecracker_rss_mb": 6153.421875, + "fc_socket_count": 131, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 132, + "boot_time_s": 2.254, + "density_at_boot": 132, + "timestamp": 1773033428.2608886, + "vms_running": 132, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.01382064819336, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 132, + "firecracker_rss_mb": 6200.08984375, + "fc_socket_count": 132, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 133, + "boot_time_s": 3.099, + "density_at_boot": 133, + "timestamp": 1773033431.521233, + "vms_running": 133, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 9.0545654296875, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 133, + "firecracker_rss_mb": 6246.50390625, + "fc_socket_count": 133, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 134, + "boot_time_s": 3.121, + "density_at_boot": 134, + "timestamp": 1773033434.803238, + "vms_running": 134, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 9.105091094970703, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 134, + "firecracker_rss_mb": 6293.42578125, + "fc_socket_count": 134, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 135, + "boot_time_s": 3.118, + "density_at_boot": 135, + "timestamp": 1773033438.0817564, + "vms_running": 135, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.156326293945312, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 135, + "firecracker_rss_mb": 6340.34765625, + "fc_socket_count": 135, + "sqlite_db_kb": 180.0 + }, + { + "event": "boot_ok", + "vm_seq": 136, + "boot_time_s": 3.123, + "density_at_boot": 136, + "timestamp": 1773033441.3631392, + "vms_running": 136, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.193977355957031, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 136, + "firecracker_rss_mb": 6387.27734375, + "fc_socket_count": 136, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 137, + "boot_time_s": 3.119, + "density_at_boot": 137, + "timestamp": 1773033444.6434557, + "vms_running": 137, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.247077941894531, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 137, + "firecracker_rss_mb": 6433.9453125, + "fc_socket_count": 137, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 138, + "boot_time_s": 3.075, + "density_at_boot": 138, + "timestamp": 1773033447.87982, + "vms_running": 138, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.296798706054688, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 138, + "firecracker_rss_mb": 6480.35546875, + "fc_socket_count": 138, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 139, + "boot_time_s": 2.222, + "density_at_boot": 139, + "timestamp": 1773033450.2640986, + "vms_running": 139, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.344768524169922, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 139, + "firecracker_rss_mb": 6527.54296875, + "fc_socket_count": 139, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 140, + "boot_time_s": 3.1, + "density_at_boot": 140, + "timestamp": 1773033453.524573, + "vms_running": 140, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.38943862915039, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 140, + "firecracker_rss_mb": 6574.21484375, + "fc_socket_count": 140, + "sqlite_db_kb": 184.0 + }, + { + "event": "boot_ok", + "vm_seq": 141, + "boot_time_s": 3.117, + "density_at_boot": 141, + "timestamp": 1773033456.803698, + "vms_running": 141, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.433296203613281, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 141, + "firecracker_rss_mb": 6622.17578125, + "fc_socket_count": 141, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 142, + "boot_time_s": 3.115, + "density_at_boot": 142, + "timestamp": 1773033460.0809586, + "vms_running": 142, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.485233306884766, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 142, + "firecracker_rss_mb": 6669.10546875, + "fc_socket_count": 142, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 143, + "boot_time_s": 2.257, + "density_at_boot": 143, + "timestamp": 1773033462.5032816, + "vms_running": 143, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.534984588623047, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 143, + "firecracker_rss_mb": 6715.7734375, + "fc_socket_count": 143, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 144, + "boot_time_s": 3.092, + "density_at_boot": 144, + "timestamp": 1773033465.7614236, + "vms_running": 144, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.581172943115234, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 144, + "firecracker_rss_mb": 6762.18359375, + "fc_socket_count": 144, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 145, + "boot_time_s": 2.259, + "density_at_boot": 145, + "timestamp": 1773033468.1824205, + "vms_running": 145, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.623035430908203, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 145, + "firecracker_rss_mb": 6808.59375, + "fc_socket_count": 145, + "sqlite_db_kb": 188.0 + }, + { + "event": "boot_ok", + "vm_seq": 146, + "boot_time_s": 2.237, + "density_at_boot": 146, + "timestamp": 1773033470.5823827, + "vms_running": 146, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.670127868652344, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 146, + "firecracker_rss_mb": 6855.7734375, + "fc_socket_count": 146, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 147, + "boot_time_s": 3.099, + "density_at_boot": 147, + "timestamp": 1773033473.8449368, + "vms_running": 147, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.725379943847656, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 147, + "firecracker_rss_mb": 6903.4765625, + "fc_socket_count": 147, + "sqlite_db_kb": 192.0 + }, + { + "event": "boot_ok", + "vm_seq": 148, + "boot_time_s": 3.113, + "density_at_boot": 148, + "timestamp": 1773033477.121257, + "vms_running": 148, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.766246795654297, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 148, + "firecracker_rss_mb": 6950.1484375, + "fc_socket_count": 148, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 149, + "boot_time_s": 2.34, + "density_at_boot": 149, + "timestamp": 1773033479.6245906, + "vms_running": 149, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.817317962646484, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 149, + "firecracker_rss_mb": 6996.8203125, + "fc_socket_count": 149, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 150, + "boot_time_s": 3.093, + "density_at_boot": 150, + "timestamp": 1773033482.8818614, + "vms_running": 150, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 9.861000061035156, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 150, + "firecracker_rss_mb": 7043.4921875, + "fc_socket_count": 150, + "sqlite_db_kb": 196.0 + }, + { + "event": "boot_ok", + "vm_seq": 151, + "boot_time_s": 3.116, + "density_at_boot": 151, + "timestamp": 1773033486.1640375, + "vms_running": 151, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.906044006347656, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 151, + "firecracker_rss_mb": 7090.15625, + "fc_socket_count": 151, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 152, + "boot_time_s": 3.193, + "density_at_boot": 152, + "timestamp": 1773033489.521806, + "vms_running": 152, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 9.950984954833984, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 152, + "firecracker_rss_mb": 7136.828125, + "fc_socket_count": 152, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 153, + "boot_time_s": 3.194, + "density_at_boot": 153, + "timestamp": 1773033492.8805733, + "vms_running": 153, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 9.998855590820312, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 153, + "firecracker_rss_mb": 7183.75390625, + "fc_socket_count": 153, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 154, + "boot_time_s": 2.252, + "density_at_boot": 154, + "timestamp": 1773033495.3022184, + "vms_running": 154, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.040069580078125, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 154, + "firecracker_rss_mb": 7230.42578125, + "fc_socket_count": 154, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 155, + "boot_time_s": 3.254, + "density_at_boot": 155, + "timestamp": 1773033498.7247493, + "vms_running": 155, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.091270446777344, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 155, + "firecracker_rss_mb": 7277.09375, + "fc_socket_count": 155, + "sqlite_db_kb": 200.0 + }, + { + "event": "boot_ok", + "vm_seq": 156, + "boot_time_s": 3.193, + "density_at_boot": 156, + "timestamp": 1773033502.0826788, + "vms_running": 156, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.131889343261719, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 156, + "firecracker_rss_mb": 7324.26953125, + "fc_socket_count": 156, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 157, + "boot_time_s": 3.119, + "density_at_boot": 157, + "timestamp": 1773033505.362828, + "vms_running": 157, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.181037902832031, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 157, + "firecracker_rss_mb": 7370.94140625, + "fc_socket_count": 157, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 158, + "boot_time_s": 3.112, + "density_at_boot": 158, + "timestamp": 1773033508.6444862, + "vms_running": 158, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.230438232421875, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 158, + "firecracker_rss_mb": 7417.87109375, + "fc_socket_count": 158, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 159, + "boot_time_s": 3.109, + "density_at_boot": 159, + "timestamp": 1773033511.9205093, + "vms_running": 159, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.284061431884766, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 159, + "firecracker_rss_mb": 7464.796875, + "fc_socket_count": 159, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 160, + "boot_time_s": 3.194, + "density_at_boot": 160, + "timestamp": 1773033515.2842944, + "vms_running": 160, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.324714660644531, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 160, + "firecracker_rss_mb": 7511.203125, + "fc_socket_count": 160, + "sqlite_db_kb": 204.0 + }, + { + "event": "boot_ok", + "vm_seq": 161, + "boot_time_s": 2.253, + "density_at_boot": 161, + "timestamp": 1773033517.7042155, + "vms_running": 161, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.376792907714844, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 161, + "firecracker_rss_mb": 7558.12890625, + "fc_socket_count": 161, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 162, + "boot_time_s": 3.094, + "density_at_boot": 162, + "timestamp": 1773033520.9644217, + "vms_running": 162, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.431446075439453, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 162, + "firecracker_rss_mb": 7605.0546875, + "fc_socket_count": 162, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 163, + "boot_time_s": 3.11, + "density_at_boot": 163, + "timestamp": 1773033524.243907, + "vms_running": 163, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.468460083007812, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 163, + "firecracker_rss_mb": 7651.98046875, + "fc_socket_count": 163, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 164, + "boot_time_s": 3.191, + "density_at_boot": 164, + "timestamp": 1773033527.6043, + "vms_running": 164, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.510318756103516, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 164, + "firecracker_rss_mb": 7698.90625, + "fc_socket_count": 164, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 165, + "boot_time_s": 3.108, + "density_at_boot": 165, + "timestamp": 1773033530.8813622, + "vms_running": 165, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.557815551757812, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 165, + "firecracker_rss_mb": 7745.8359375, + "fc_socket_count": 165, + "sqlite_db_kb": 208.0 + }, + { + "event": "boot_ok", + "vm_seq": 166, + "boot_time_s": 3.123, + "density_at_boot": 166, + "timestamp": 1773033534.1663275, + "vms_running": 166, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.608741760253906, + "host_disk_used_gb": 2.0564804077148438, + "tap_count": 166, + "firecracker_rss_mb": 7793.01953125, + "fc_socket_count": 166, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 167, + "boot_time_s": 3.189, + "density_at_boot": 167, + "timestamp": 1773033537.5240815, + "vms_running": 167, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.653961181640625, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 167, + "firecracker_rss_mb": 7839.94140625, + "fc_socket_count": 167, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 168, + "boot_time_s": 2.25, + "density_at_boot": 168, + "timestamp": 1773033539.9457948, + "vms_running": 168, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 10.698810577392578, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 168, + "firecracker_rss_mb": 7886.61328125, + "fc_socket_count": 168, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 169, + "boot_time_s": 3.168, + "density_at_boot": 169, + "timestamp": 1773033543.2839813, + "vms_running": 169, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.747535705566406, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 169, + "firecracker_rss_mb": 7933.5390625, + "fc_socket_count": 169, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 170, + "boot_time_s": 3.347, + "density_at_boot": 170, + "timestamp": 1773033546.8029087, + "vms_running": 170, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 10.788501739501953, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 170, + "firecracker_rss_mb": 7980.2109375, + "fc_socket_count": 170, + "sqlite_db_kb": 212.0 + }, + { + "event": "boot_ok", + "vm_seq": 171, + "boot_time_s": 3.111, + "density_at_boot": 171, + "timestamp": 1773033550.0837052, + "vms_running": 171, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.838539123535156, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 171, + "firecracker_rss_mb": 8026.625, + "fc_socket_count": 171, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 172, + "boot_time_s": 3.107, + "density_at_boot": 172, + "timestamp": 1773033553.3607836, + "vms_running": 172, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 10.891731262207031, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 172, + "firecracker_rss_mb": 8073.5546875, + "fc_socket_count": 172, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 173, + "boot_time_s": 3.191, + "density_at_boot": 173, + "timestamp": 1773033556.7229428, + "vms_running": 173, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 10.934406280517578, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 173, + "firecracker_rss_mb": 8119.96484375, + "fc_socket_count": 173, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 174, + "boot_time_s": 3.111, + "density_at_boot": 174, + "timestamp": 1773033560.0019217, + "vms_running": 174, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 10.979808807373047, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 174, + "firecracker_rss_mb": 8166.890625, + "fc_socket_count": 174, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 175, + "boot_time_s": 3.111, + "density_at_boot": 175, + "timestamp": 1773033563.2828329, + "vms_running": 175, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.024150848388672, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 175, + "firecracker_rss_mb": 8213.55859375, + "fc_socket_count": 175, + "sqlite_db_kb": 216.0 + }, + { + "event": "boot_ok", + "vm_seq": 176, + "boot_time_s": 3.068, + "density_at_boot": 176, + "timestamp": 1773033566.5202913, + "vms_running": 176, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.070877075195312, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 176, + "firecracker_rss_mb": 8259.96484375, + "fc_socket_count": 176, + "sqlite_db_kb": 220.0 + }, + { + "event": "boot_ok", + "vm_seq": 177, + "boot_time_s": 3.15, + "density_at_boot": 177, + "timestamp": 1773033569.841767, + "vms_running": 177, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.11007308959961, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 177, + "firecracker_rss_mb": 8306.89453125, + "fc_socket_count": 177, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 178, + "boot_time_s": 3.109, + "density_at_boot": 178, + "timestamp": 1773033573.1206295, + "vms_running": 178, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.160285949707031, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 178, + "firecracker_rss_mb": 8353.82421875, + "fc_socket_count": 178, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 179, + "boot_time_s": 2.253, + "density_at_boot": 179, + "timestamp": 1773033575.5447557, + "vms_running": 179, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.212104797363281, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 179, + "firecracker_rss_mb": 8400.75, + "fc_socket_count": 179, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 180, + "boot_time_s": 3.165, + "density_at_boot": 180, + "timestamp": 1773033578.8825028, + "vms_running": 180, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.261924743652344, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 180, + "firecracker_rss_mb": 8447.9375, + "fc_socket_count": 180, + "sqlite_db_kb": 224.0 + }, + { + "event": "boot_ok", + "vm_seq": 181, + "boot_time_s": 3.193, + "density_at_boot": 181, + "timestamp": 1773033582.2439106, + "vms_running": 181, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.309494018554688, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 181, + "firecracker_rss_mb": 8494.86328125, + "fc_socket_count": 181, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 182, + "boot_time_s": 3.188, + "density_at_boot": 182, + "timestamp": 1773033585.6021996, + "vms_running": 182, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.352672576904297, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 182, + "firecracker_rss_mb": 8541.2734375, + "fc_socket_count": 182, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 183, + "boot_time_s": 3.149, + "density_at_boot": 183, + "timestamp": 1773033588.9205325, + "vms_running": 183, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.397899627685547, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 183, + "firecracker_rss_mb": 8588.45703125, + "fc_socket_count": 183, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 184, + "boot_time_s": 3.157, + "density_at_boot": 184, + "timestamp": 1773033592.2446215, + "vms_running": 184, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.445987701416016, + "host_disk_used_gb": 2.056476593017578, + "tap_count": 184, + "firecracker_rss_mb": 8635.12890625, + "fc_socket_count": 184, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 185, + "boot_time_s": 3.19, + "density_at_boot": 185, + "timestamp": 1773033595.6052225, + "vms_running": 185, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.482105255126953, + "host_disk_used_gb": 2.064289093017578, + "tap_count": 185, + "firecracker_rss_mb": 8682.3125, + "fc_socket_count": 185, + "sqlite_db_kb": 228.0 + }, + { + "event": "boot_ok", + "vm_seq": 186, + "boot_time_s": 3.188, + "density_at_boot": 186, + "timestamp": 1773033598.9635153, + "vms_running": 186, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.541004180908203, + "host_disk_used_gb": 2.068195343017578, + "tap_count": 186, + "firecracker_rss_mb": 8729.23828125, + "fc_socket_count": 186, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 187, + "boot_time_s": 2.226, + "density_at_boot": 187, + "timestamp": 1773033601.3632512, + "vms_running": 187, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 11.587959289550781, + "host_disk_used_gb": 2.0681991577148438, + "tap_count": 187, + "firecracker_rss_mb": 8775.90625, + "fc_socket_count": 187, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 188, + "boot_time_s": 3.346, + "density_at_boot": 188, + "timestamp": 1773033604.8829737, + "vms_running": 188, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.639976501464844, + "host_disk_used_gb": 2.068256378173828, + "tap_count": 188, + "firecracker_rss_mb": 8822.578125, + "fc_socket_count": 188, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 189, + "boot_time_s": 3.187, + "density_at_boot": 189, + "timestamp": 1773033608.2422018, + "vms_running": 189, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.687469482421875, + "host_disk_used_gb": 2.0682373046875, + "tap_count": 189, + "firecracker_rss_mb": 8868.98828125, + "fc_socket_count": 189, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 190, + "boot_time_s": 3.271, + "density_at_boot": 190, + "timestamp": 1773033611.6846218, + "vms_running": 190, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.74105453491211, + "host_disk_used_gb": 2.0682373046875, + "tap_count": 190, + "firecracker_rss_mb": 8916.17578125, + "fc_socket_count": 190, + "sqlite_db_kb": 232.0 + }, + { + "event": "boot_ok", + "vm_seq": 191, + "boot_time_s": 2.209, + "density_at_boot": 191, + "timestamp": 1773033614.0609727, + "vms_running": 191, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 11.793479919433594, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 191, + "firecracker_rss_mb": 8963.1015625, + "fc_socket_count": 191, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 192, + "boot_time_s": 2.264, + "density_at_boot": 192, + "timestamp": 1773033616.501715, + "vms_running": 192, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 11.839092254638672, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 192, + "firecracker_rss_mb": 9009.2578125, + "fc_socket_count": 192, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 193, + "boot_time_s": 3.328, + "density_at_boot": 193, + "timestamp": 1773033620.0044794, + "vms_running": 193, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.886859893798828, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 193, + "firecracker_rss_mb": 9055.671875, + "fc_socket_count": 193, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 194, + "boot_time_s": 3.187, + "density_at_boot": 194, + "timestamp": 1773033623.3625393, + "vms_running": 194, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 11.928947448730469, + "host_disk_used_gb": 2.0682601928710938, + "tap_count": 194, + "firecracker_rss_mb": 9102.6015625, + "fc_socket_count": 194, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 195, + "boot_time_s": 3.194, + "density_at_boot": 195, + "timestamp": 1773033626.7250767, + "vms_running": 195, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 11.971641540527344, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 195, + "firecracker_rss_mb": 9149.26953125, + "fc_socket_count": 195, + "sqlite_db_kb": 236.0 + }, + { + "event": "boot_ok", + "vm_seq": 196, + "boot_time_s": 3.185, + "density_at_boot": 196, + "timestamp": 1773033630.0824122, + "vms_running": 196, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.018150329589844, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 196, + "firecracker_rss_mb": 9196.453125, + "fc_socket_count": 196, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 197, + "boot_time_s": 3.188, + "density_at_boot": 197, + "timestamp": 1773033633.4426615, + "vms_running": 197, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 12.065910339355469, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 197, + "firecracker_rss_mb": 9243.3828125, + "fc_socket_count": 197, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 198, + "boot_time_s": 3.187, + "density_at_boot": 198, + "timestamp": 1773033636.802098, + "vms_running": 198, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.115619659423828, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 198, + "firecracker_rss_mb": 9290.30859375, + "fc_socket_count": 198, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 199, + "boot_time_s": 3.141, + "density_at_boot": 199, + "timestamp": 1773033640.119371, + "vms_running": 199, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.157161712646484, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 199, + "firecracker_rss_mb": 9337.23828125, + "fc_socket_count": 199, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 200, + "boot_time_s": 3.15, + "density_at_boot": 200, + "timestamp": 1773033643.4410403, + "vms_running": 200, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.199546813964844, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 200, + "firecracker_rss_mb": 9383.65234375, + "fc_socket_count": 200, + "sqlite_db_kb": 240.0 + }, + { + "event": "boot_ok", + "vm_seq": 201, + "boot_time_s": 3.187, + "density_at_boot": 201, + "timestamp": 1773033646.8031938, + "vms_running": 201, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.243377685546875, + "host_disk_used_gb": 2.0682830810546875, + "tap_count": 201, + "firecracker_rss_mb": 9430.83984375, + "fc_socket_count": 201, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 202, + "boot_time_s": 2.21, + "density_at_boot": 202, + "timestamp": 1773033649.1886933, + "vms_running": 202, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.294654846191406, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 202, + "firecracker_rss_mb": 9477.51171875, + "fc_socket_count": 202, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 203, + "boot_time_s": 3.117, + "density_at_boot": 203, + "timestamp": 1773033652.4823601, + "vms_running": 203, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 12.346118927001953, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 203, + "firecracker_rss_mb": 9524.9609375, + "fc_socket_count": 203, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 204, + "boot_time_s": 3.184, + "density_at_boot": 204, + "timestamp": 1773033655.8429387, + "vms_running": 204, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.397769927978516, + "host_disk_used_gb": 2.0682640075683594, + "tap_count": 204, + "firecracker_rss_mb": 9571.6328125, + "fc_socket_count": 204, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 205, + "boot_time_s": 3.185, + "density_at_boot": 205, + "timestamp": 1773033659.2011416, + "vms_running": 205, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.447380065917969, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 205, + "firecracker_rss_mb": 9618.5546875, + "fc_socket_count": 205, + "sqlite_db_kb": 244.0 + }, + { + "event": "boot_ok", + "vm_seq": 206, + "boot_time_s": 3.141, + "density_at_boot": 206, + "timestamp": 1773033662.5197165, + "vms_running": 206, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.492847442626953, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 206, + "firecracker_rss_mb": 9665.484375, + "fc_socket_count": 206, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 207, + "boot_time_s": 3.183, + "density_at_boot": 207, + "timestamp": 1773033665.8796723, + "vms_running": 207, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.531898498535156, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 207, + "firecracker_rss_mb": 9712.1484375, + "fc_socket_count": 207, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 208, + "boot_time_s": 3.224, + "density_at_boot": 208, + "timestamp": 1773033669.2808225, + "vms_running": 208, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 12.575054168701172, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 208, + "firecracker_rss_mb": 9759.08203125, + "fc_socket_count": 208, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 209, + "boot_time_s": 3.191, + "density_at_boot": 209, + "timestamp": 1773033672.6431203, + "vms_running": 209, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.619369506835938, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 209, + "firecracker_rss_mb": 9805.75390625, + "fc_socket_count": 209, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 210, + "boot_time_s": 2.493, + "density_at_boot": 210, + "timestamp": 1773033675.3110383, + "vms_running": 210, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 12.677513122558594, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 210, + "firecracker_rss_mb": 9852.9375, + "fc_socket_count": 210, + "sqlite_db_kb": 248.0 + }, + { + "event": "boot_ok", + "vm_seq": 211, + "boot_time_s": 3.235, + "density_at_boot": 211, + "timestamp": 1773033678.7220268, + "vms_running": 211, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.724494934082031, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 211, + "firecracker_rss_mb": 9900.1171875, + "fc_socket_count": 211, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 212, + "boot_time_s": 3.18, + "density_at_boot": 212, + "timestamp": 1773033682.0824926, + "vms_running": 212, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.762870788574219, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 212, + "firecracker_rss_mb": 9946.78125, + "fc_socket_count": 212, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 213, + "boot_time_s": 3.265, + "density_at_boot": 213, + "timestamp": 1773033685.5220332, + "vms_running": 213, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.811355590820312, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 213, + "firecracker_rss_mb": 9993.70703125, + "fc_socket_count": 213, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 214, + "boot_time_s": 2.224, + "density_at_boot": 214, + "timestamp": 1773033687.9207778, + "vms_running": 214, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.849857330322266, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 214, + "firecracker_rss_mb": 10040.37890625, + "fc_socket_count": 214, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 215, + "boot_time_s": 3.185, + "density_at_boot": 215, + "timestamp": 1773033691.2841442, + "vms_running": 215, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.905830383300781, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 215, + "firecracker_rss_mb": 10087.30859375, + "fc_socket_count": 215, + "sqlite_db_kb": 252.0 + }, + { + "event": "boot_ok", + "vm_seq": 216, + "boot_time_s": 2.32, + "density_at_boot": 216, + "timestamp": 1773033693.7820256, + "vms_running": 216, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 12.955081939697266, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 216, + "firecracker_rss_mb": 10133.72265625, + "fc_socket_count": 216, + "sqlite_db_kb": 256.0 + }, + { + "event": "boot_ok", + "vm_seq": 217, + "boot_time_s": 3.163, + "density_at_boot": 217, + "timestamp": 1773033697.1216776, + "vms_running": 217, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 12.997241973876953, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 217, + "firecracker_rss_mb": 10180.6484375, + "fc_socket_count": 217, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 218, + "boot_time_s": 3.265, + "density_at_boot": 218, + "timestamp": 1773033700.5650856, + "vms_running": 218, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.045398712158203, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 218, + "firecracker_rss_mb": 10227.83203125, + "fc_socket_count": 218, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 219, + "boot_time_s": 2.279, + "density_at_boot": 219, + "timestamp": 1773033703.022103, + "vms_running": 219, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.093620300292969, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 219, + "firecracker_rss_mb": 10275.2734375, + "fc_socket_count": 219, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 220, + "boot_time_s": 2.433, + "density_at_boot": 220, + "timestamp": 1773033705.6311026, + "vms_running": 220, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.141223907470703, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 220, + "firecracker_rss_mb": 10322.19921875, + "fc_socket_count": 220, + "sqlite_db_kb": 264.0 + }, + { + "event": "boot_ok", + "vm_seq": 221, + "boot_time_s": 3.156, + "density_at_boot": 221, + "timestamp": 1773033708.9627576, + "vms_running": 221, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.182518005371094, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 221, + "firecracker_rss_mb": 10368.8671875, + "fc_socket_count": 221, + "sqlite_db_kb": 272.0 + }, + { + "event": "boot_ok", + "vm_seq": 222, + "boot_time_s": 2.405, + "density_at_boot": 222, + "timestamp": 1773033711.541123, + "vms_running": 222, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.22659683227539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 222, + "firecracker_rss_mb": 10415.53515625, + "fc_socket_count": 222, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 223, + "boot_time_s": 2.305, + "density_at_boot": 223, + "timestamp": 1773033714.0210059, + "vms_running": 223, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.278278350830078, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 223, + "firecracker_rss_mb": 10462.4609375, + "fc_socket_count": 223, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 224, + "boot_time_s": 3.239, + "density_at_boot": 224, + "timestamp": 1773033717.4414132, + "vms_running": 224, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.334373474121094, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 224, + "firecracker_rss_mb": 10509.1328125, + "fc_socket_count": 224, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 225, + "boot_time_s": 2.319, + "density_at_boot": 225, + "timestamp": 1773033719.9409328, + "vms_running": 225, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.38070297241211, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 225, + "firecracker_rss_mb": 10555.8046875, + "fc_socket_count": 225, + "sqlite_db_kb": 312.0 + }, + { + "event": "boot_ok", + "vm_seq": 226, + "boot_time_s": 3.323, + "density_at_boot": 226, + "timestamp": 1773033723.4444726, + "vms_running": 226, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.42630386352539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 226, + "firecracker_rss_mb": 10602.7265625, + "fc_socket_count": 226, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 227, + "boot_time_s": 3.176, + "density_at_boot": 227, + "timestamp": 1773033726.8020544, + "vms_running": 227, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.469928741455078, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 227, + "firecracker_rss_mb": 10649.390625, + "fc_socket_count": 227, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 228, + "boot_time_s": 3.187, + "density_at_boot": 228, + "timestamp": 1773033730.1644514, + "vms_running": 228, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.523738861083984, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 228, + "firecracker_rss_mb": 10696.3203125, + "fc_socket_count": 228, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 229, + "boot_time_s": 3.262, + "density_at_boot": 229, + "timestamp": 1773033733.6042023, + "vms_running": 229, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.56546401977539, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 229, + "firecracker_rss_mb": 10743.50390625, + "fc_socket_count": 229, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 230, + "boot_time_s": 3.259, + "density_at_boot": 230, + "timestamp": 1773033737.0411217, + "vms_running": 230, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.606185913085938, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 230, + "firecracker_rss_mb": 10790.16796875, + "fc_socket_count": 230, + "sqlite_db_kb": 316.0 + }, + { + "event": "boot_ok", + "vm_seq": 231, + "boot_time_s": 3.261, + "density_at_boot": 231, + "timestamp": 1773033740.4821775, + "vms_running": 231, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 13.671470642089844, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 231, + "firecracker_rss_mb": 10837.09765625, + "fc_socket_count": 231, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 232, + "boot_time_s": 3.175, + "density_at_boot": 232, + "timestamp": 1773033743.8407533, + "vms_running": 232, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.712615966796875, + "host_disk_used_gb": 2.0682449340820312, + "tap_count": 232, + "firecracker_rss_mb": 10884.0234375, + "fc_socket_count": 232, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 233, + "boot_time_s": 3.221, + "density_at_boot": 233, + "timestamp": 1773033747.2403154, + "vms_running": 233, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 13.756458282470703, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 233, + "firecracker_rss_mb": 10930.94921875, + "fc_socket_count": 233, + "sqlite_db_kb": 320.0 + }, + { + "event": "boot_ok", + "vm_seq": 234, + "boot_time_s": 2.28, + "density_at_boot": 234, + "timestamp": 1773033749.7022865, + "vms_running": 234, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.799877166748047, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 234, + "firecracker_rss_mb": 10978.13671875, + "fc_socket_count": 234, + "sqlite_db_kb": 324.0 + }, + { + "event": "boot_ok", + "vm_seq": 235, + "boot_time_s": 3.32, + "density_at_boot": 235, + "timestamp": 1773033753.2051058, + "vms_running": 235, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.846595764160156, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 235, + "firecracker_rss_mb": 11024.80859375, + "fc_socket_count": 235, + "sqlite_db_kb": 324.0 + }, + { + "event": "boot_ok", + "vm_seq": 236, + "boot_time_s": 3.259, + "density_at_boot": 236, + "timestamp": 1773033756.6450055, + "vms_running": 236, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 13.88980484008789, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 236, + "firecracker_rss_mb": 11071.734375, + "fc_socket_count": 236, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 237, + "boot_time_s": 3.262, + "density_at_boot": 237, + "timestamp": 1773033760.0850143, + "vms_running": 237, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 13.9407958984375, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 237, + "firecracker_rss_mb": 11118.40234375, + "fc_socket_count": 237, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 238, + "boot_time_s": 3.258, + "density_at_boot": 238, + "timestamp": 1773033763.5224333, + "vms_running": 238, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 13.986568450927734, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 238, + "firecracker_rss_mb": 11165.5859375, + "fc_socket_count": 238, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 239, + "boot_time_s": 3.257, + "density_at_boot": 239, + "timestamp": 1773033766.9620733, + "vms_running": 239, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.035202026367188, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 239, + "firecracker_rss_mb": 11212.25390625, + "fc_socket_count": 239, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 240, + "boot_time_s": 3.34, + "density_at_boot": 240, + "timestamp": 1773033770.482531, + "vms_running": 240, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.085208892822266, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 240, + "firecracker_rss_mb": 11259.18359375, + "fc_socket_count": 240, + "sqlite_db_kb": 328.0 + }, + { + "event": "boot_ok", + "vm_seq": 241, + "boot_time_s": 2.274, + "density_at_boot": 241, + "timestamp": 1773033772.939943, + "vms_running": 241, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.136260986328125, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 241, + "firecracker_rss_mb": 11305.6015625, + "fc_socket_count": 241, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 242, + "boot_time_s": 3.284, + "density_at_boot": 242, + "timestamp": 1773033776.4048007, + "vms_running": 242, + "host_cpu_pct": 0.6, + "host_mem_used_gb": 14.17977523803711, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 242, + "firecracker_rss_mb": 11352.2734375, + "fc_socket_count": 242, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 243, + "boot_time_s": 2.318, + "density_at_boot": 243, + "timestamp": 1773033778.9048815, + "vms_running": 243, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 14.225570678710938, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 243, + "firecracker_rss_mb": 11399.97265625, + "fc_socket_count": 243, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 244, + "boot_time_s": 3.241, + "density_at_boot": 244, + "timestamp": 1773033782.3236187, + "vms_running": 244, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.274162292480469, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 244, + "firecracker_rss_mb": 11446.90234375, + "fc_socket_count": 244, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 245, + "boot_time_s": 3.412, + "density_at_boot": 245, + "timestamp": 1773033785.9220474, + "vms_running": 245, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.318473815917969, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 245, + "firecracker_rss_mb": 11493.3125, + "fc_socket_count": 245, + "sqlite_db_kb": 332.0 + }, + { + "event": "boot_ok", + "vm_seq": 246, + "boot_time_s": 3.255, + "density_at_boot": 246, + "timestamp": 1773033789.3639004, + "vms_running": 246, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.37160873413086, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 246, + "firecracker_rss_mb": 11539.7265625, + "fc_socket_count": 246, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 247, + "boot_time_s": 3.259, + "density_at_boot": 247, + "timestamp": 1773033792.8039594, + "vms_running": 247, + "host_cpu_pct": 0.4, + "host_mem_used_gb": 14.427932739257812, + "host_disk_used_gb": 2.0760574340820312, + "tap_count": 247, + "firecracker_rss_mb": 11586.65234375, + "fc_socket_count": 247, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 248, + "boot_time_s": 3.26, + "density_at_boot": 248, + "timestamp": 1773033796.244873, + "vms_running": 248, + "host_cpu_pct": 0.1, + "host_mem_used_gb": 14.464420318603516, + "host_disk_used_gb": 2.074138641357422, + "tap_count": 248, + "firecracker_rss_mb": 11633.32421875, + "fc_socket_count": 248, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 249, + "boot_time_s": 3.26, + "density_at_boot": 249, + "timestamp": 1773033799.6849911, + "vms_running": 249, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.509002685546875, + "host_disk_used_gb": 2.074169158935547, + "tap_count": 249, + "firecracker_rss_mb": 11680.25, + "fc_socket_count": 249, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 250, + "boot_time_s": 3.131, + "density_at_boot": 250, + "timestamp": 1773033803.0008395, + "vms_running": 250, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.562793731689453, + "host_disk_used_gb": 2.074230194091797, + "tap_count": 250, + "firecracker_rss_mb": 11727.43359375, + "fc_socket_count": 250, + "sqlite_db_kb": 336.0 + }, + { + "event": "boot_ok", + "vm_seq": 251, + "boot_time_s": 3.217, + "density_at_boot": 251, + "timestamp": 1773033806.4029758, + "vms_running": 251, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.611839294433594, + "host_disk_used_gb": 2.0742530822753906, + "tap_count": 251, + "firecracker_rss_mb": 11774.62109375, + "fc_socket_count": 251, + "sqlite_db_kb": 340.0 + }, + { + "event": "boot_ok", + "vm_seq": 252, + "boot_time_s": 3.417, + "density_at_boot": 252, + "timestamp": 1773033810.0056808, + "vms_running": 252, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 14.651336669921875, + "host_disk_used_gb": 2.0743331909179688, + "tap_count": 252, + "firecracker_rss_mb": 11822.0625, + "fc_socket_count": 252, + "sqlite_db_kb": 340.0 + }, + { + "event": "boot_ok", + "vm_seq": 253, + "boot_time_s": 3.25, + "density_at_boot": 253, + "timestamp": 1773033813.440772, + "vms_running": 253, + "host_cpu_pct": 0.2, + "host_mem_used_gb": 14.702342987060547, + "host_disk_used_gb": 2.0743141174316406, + "tap_count": 253, + "firecracker_rss_mb": 11868.73046875, + "fc_socket_count": 253, + "sqlite_db_kb": 340.0 + }, + { + "event": "sustain_check", + "sustain_sec": 60, + "vms_alive": 253, + "vms_dead": [], + "vms_checked": 253, + "timestamp": 1773033874.0488198, + "vms_running": 253, + "host_cpu_pct": 0.3, + "host_mem_used_gb": 14.580455780029297, + "host_disk_used_gb": 2.074298858642578, + "tap_count": 253, + "firecracker_rss_mb": 11942.98046875, + "fc_socket_count": 253, + "sqlite_db_kb": 340.0 + }, + { + "event": "teardown", + "teardown_time_s": 127.52, + "timestamp": 1773034001.7450569, + "vms_running": 0, + "host_cpu_pct": 0.0, + "host_mem_used_gb": 3.0937042236328125, + "host_disk_used_gb": 2.0742874145507812, + "tap_count": 253, + "firecracker_rss_mb": 0.0, + "fc_socket_count": 0, + "sqlite_db_kb": 340.0 + } +] \ No newline at end of file diff --git a/benchmarks/run_density_ramp_gcp.sh b/benchmarks/run_density_ramp_gcp.sh new file mode 100755 index 0000000..ed51ca3 --- /dev/null +++ b/benchmarks/run_density_ramp_gcp.sh @@ -0,0 +1,286 @@ +#!/usr/bin/env bash +# run_density_ramp_gcp.sh +# +# Launches a GCP instance, deploys and runs the density_ramp benchmark, +# collects results, then deletes the instance. +# +# Prerequisites: +# - gcloud CLI configured (gcloud auth login && gcloud config set project PROJECT) +# - A GCP project with the Compute Engine API enabled +# +# Usage: +# ./run_density_ramp_gcp.sh [--tier tiny|small|med] [--max-attempts N] \ +# [--sustain-sec N] [--parallel N] [--shared-disk] \ +# [--output FILE] +# +# Environment variable overrides: +# PROJECT GCP project ID (required if not set in gcloud config) +# ZONE GCP zone (default: us-central1-a) +# MACHINE_TYPE GCP machine type (default: n2-standard-16) +# IMAGE_FAMILY OS image family (default: debian-12) +# IMAGE_PROJECT OS image project (default: debian-cloud) +# FIREWALL_RULE Firewall rule name (optional; creates a temporary one if unset) + +set -euo pipefail + +# --------------------------------------------------------------------------- +# Defaults (override via environment variables) +# --------------------------------------------------------------------------- +PROJECT="${PROJECT:-$(gcloud config get-value project 2>/dev/null || true)}" +ZONE="${ZONE:-us-central1-a}" +MACHINE_TYPE="${MACHINE_TYPE:-n2-standard-16}" +IMAGE_FAMILY="${IMAGE_FAMILY:-debian-12}" +IMAGE_PROJECT="${IMAGE_PROJECT:-debian-cloud}" +FIREWALL_RULE="${FIREWALL_RULE:-}" + +# Benchmark args (overridden by CLI flags below) +TIER="tiny" +MAX_ATTEMPTS="500" +SUSTAIN_SEC="60" +PARALLEL="1" +SHARED_DISK="" +OUTPUT_FILE="density_$(date +%Y%m%d_%H%M%S).json" + +# --------------------------------------------------------------------------- +# Parse CLI flags +# --------------------------------------------------------------------------- +while [[ $# -gt 0 ]]; do + case "$1" in + --tier) TIER="$2"; shift 2 ;; + --max-attempts) MAX_ATTEMPTS="$2"; shift 2 ;; + --sustain-sec) SUSTAIN_SEC="$2"; shift 2 ;; + --parallel) PARALLEL="$2"; shift 2 ;; + --shared-disk) SHARED_DISK="--shared-disk"; shift ;; + --output) OUTPUT_FILE="$2"; shift 2 ;; + *) echo "Unknown argument: $1"; exit 1 ;; + esac +done + +# --------------------------------------------------------------------------- +# Validate prerequisites +# --------------------------------------------------------------------------- +if ! command -v gcloud &>/dev/null; then + echo "ERROR: gcloud CLI not found. Install it: https://cloud.google.com/sdk/docs/install" + exit 1 +fi + +if [[ -z "$PROJECT" ]]; then + echo "ERROR: GCP project is not set." + echo " export PROJECT=my-gcp-project" + echo " or: gcloud config set project my-gcp-project" + exit 1 +fi + +# --------------------------------------------------------------------------- +# Optionally create a temporary firewall rule allowing SSH +# --------------------------------------------------------------------------- +INSTANCE_NAME="smolvm-bench-$(date +%s)" +NETWORK_TAG="$INSTANCE_NAME" +CREATED_FIREWALL_RULE="" + +if [[ -z "$FIREWALL_RULE" ]]; then + FIREWALL_RULE="$NETWORK_TAG-ssh" + echo "Creating temporary firewall rule $FIREWALL_RULE..." + gcloud compute firewall-rules create "$FIREWALL_RULE" \ + --project="$PROJECT" \ + --direction=INGRESS \ + --action=ALLOW \ + --rules=tcp:22 \ + --source-ranges=0.0.0.0/0 \ + --target-tags="$NETWORK_TAG" \ + --quiet + CREATED_FIREWALL_RULE="$FIREWALL_RULE" + echo "Created firewall rule: $FIREWALL_RULE" +fi + +# --------------------------------------------------------------------------- +# Launch instance +# --------------------------------------------------------------------------- +INSTANCE_CREATED=0 + +cleanup() { + echo "" + echo "--- Cleanup ---" + + if [[ "$INSTANCE_CREATED" -eq 1 ]]; then + echo "Deleting instance $INSTANCE_NAME..." + gcloud compute instances delete "$INSTANCE_NAME" \ + --project="$PROJECT" \ + --zone="$ZONE" \ + --quiet 2>/dev/null || true + echo "Instance deleted." + fi + + if [[ -n "$CREATED_FIREWALL_RULE" ]]; then + echo "Deleting firewall rule $CREATED_FIREWALL_RULE..." + gcloud compute firewall-rules delete "$CREATED_FIREWALL_RULE" \ + --project="$PROJECT" \ + --quiet 2>/dev/null || true + fi +} +trap cleanup EXIT + +echo "" +echo "Launching $MACHINE_TYPE instance ($INSTANCE_NAME)..." + +# --enable-nested-virtualization is required for KVM on GCP +gcloud compute instances create "$INSTANCE_NAME" \ + --project="$PROJECT" \ + --zone="$ZONE" \ + --machine-type="$MACHINE_TYPE" \ + --image-family="$IMAGE_FAMILY" \ + --image-project="$IMAGE_PROJECT" \ + --boot-disk-size=100GB \ + --boot-disk-type=pd-ssd \ + --enable-nested-virtualization \ + --tags="$NETWORK_TAG" \ + --quiet + +INSTANCE_CREATED=1 +echo "Instance created: $INSTANCE_NAME" + +# --------------------------------------------------------------------------- +# Wait for instance to be running +# --------------------------------------------------------------------------- +echo "Waiting for instance to reach RUNNING state..." +for i in $(seq 1 30); do + STATUS=$(gcloud compute instances describe "$INSTANCE_NAME" \ + --project="$PROJECT" \ + --zone="$ZONE" \ + --format="value(status)") + if [[ "$STATUS" == "RUNNING" ]]; then + echo "Instance is running." + break + fi + if [[ $i -eq 30 ]]; then + echo "ERROR: Instance never reached RUNNING state (last status: $STATUS)." + exit 1 + fi + sleep 5 +done + +# --------------------------------------------------------------------------- +# Wait for SSH to become available +# --------------------------------------------------------------------------- +echo "Waiting for SSH to become available..." +for i in $(seq 1 30); do + if gcloud compute ssh "$INSTANCE_NAME" \ + --project="$PROJECT" \ + --zone="$ZONE" \ + --strict-host-key-checking=no \ + --command="echo ok" &>/dev/null; then + echo "SSH is up." + break + fi + if [[ $i -eq 30 ]]; then + echo "ERROR: SSH never became available." + exit 1 + fi + sleep 10 +done + +GSSH=(gcloud compute ssh "$INSTANCE_NAME" + --project="$PROJECT" + --zone="$ZONE" + --strict-host-key-checking=no +) +GSCP=(gcloud compute scp + --project="$PROJECT" + --zone="$ZONE" + --strict-host-key-checking=no +) + +# --------------------------------------------------------------------------- +# Install dependencies on the instance +# --------------------------------------------------------------------------- +echo "" +echo "--- Installing dependencies ---" +"${GSSH[@]}" --command="bash -s" <<'REMOTE' +set -euo pipefail + +# Enable KVM access +sudo usermod -aG kvm "$USER" || true +sudo chmod 666 /dev/kvm + +# Install Python and pip +sudo apt-get update -qq +sudo apt-get install -y -qq python3 python3-pip + +# Install smolvm and psutil +pip3 install --quiet smolvm psutil + +# Trigger Firecracker binary download +smolvm demo list 2>/dev/null || true +REMOTE + +echo "Dependencies installed." + +# --------------------------------------------------------------------------- +# Upload benchmark script +# --------------------------------------------------------------------------- +echo "" +echo "--- Uploading benchmark ---" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +"${GSCP[@]}" \ + "$SCRIPT_DIR/density_ramp.py" \ + "${INSTANCE_NAME}:~/density_ramp.py" +echo "Uploaded density_ramp.py" + +# --------------------------------------------------------------------------- +# Run benchmark +# --------------------------------------------------------------------------- +REMOTE_OUTPUT="density.json" +BENCHMARK_CMD="python3 ~/density_ramp.py \ + --tier $TIER \ + --max-attempts $MAX_ATTEMPTS \ + --sustain-sec $SUSTAIN_SEC \ + --parallel $PARALLEL \ + ${SHARED_DISK} \ + --output ~/$REMOTE_OUTPUT" + +echo "" +echo "--- Running benchmark ---" +echo " tier=$TIER max-attempts=$MAX_ATTEMPTS sustain-sec=$SUSTAIN_SEC parallel=$PARALLEL ${SHARED_DISK:+shared-disk}" +echo "" + +# Run with a pseudo-TTY so output streams live; failure here still triggers cleanup +"${GSSH[@]}" --command="$BENCHMARK_CMD" -- -t || { + echo "" + echo "WARNING: Benchmark exited with a non-zero status (may be expected at resource limit)." +} + +# --------------------------------------------------------------------------- +# Collect results +# --------------------------------------------------------------------------- +echo "" +echo "--- Collecting results ---" +"${GSCP[@]}" \ + "${INSTANCE_NAME}:~/$REMOTE_OUTPUT" \ + "./$OUTPUT_FILE" + +echo "Results saved to: $OUTPUT_FILE" +echo "" +echo "Quick summary:" +python3 - "$OUTPUT_FILE" <<'PYEOF' +import json, sys + +with open(sys.argv[1]) as f: + data = json.load(f) + +boots = [d for d in data if d.get("event") == "boot_ok"] +fails = [d for d in data if d.get("event") == "boot_fail"] +sustain = next((d for d in data if d.get("event") == "sustain_check"), None) + +print(f" Successful boots : {len(boots)}") +print(f" Failed boots : {len(fails)}") +if boots: + times = [d["boot_time_s"] for d in boots] + print(f" Boot time avg : {sum(times)/len(times):.2f}s") + print(f" Boot time max : {max(times):.2f}s") + last = boots[-1] + print(f" Peak mem used : {last['host_mem_used_gb']:.2f} GB") +if sustain: + print(f" Sustain alive : {sustain['vms_alive']}/{sustain['vms_checked']} VMs") +PYEOF + +# Instance is deleted by the cleanup trap on EXIT From 0d66e6173e0f0f6b4cf19d7d66a37e0c3ea69c07 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:10:30 -0400 Subject: [PATCH 13/20] fix: address CodeRabbit review comments on density ramp benchmark PR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - build.py: validate symlink/hardlink targets in tar security check - build.py: chown ext4 output to caller after Docker run (rootful Docker leaves root-owned file) - density_ramp.py: vm.stop() → vm.delete() so disk clones are released; log cleanup failures - density_ramp.py: measure disk usage on SmolVM storage path (follows NVMe symlink on EC2) - density_ramp.py: capture metrics snapshot per-future in parallel path, not post-batch - bench_network_io.py: abort with RuntimeError if no HTTP client after apk add attempt - helpers.py: timer context manager uses try/finally so elapsed_ms is set on exception - bench_*.py: package-safe try/except import for helpers (relative then absolute) - run_density_ramp_ec2.sh: fix KEY_NAME env override; restrict SSH rule to caller IP; guard NVMe provisioning on device existence - run_density_ramp_gcp.sh: restrict SSH rule to caller IP; use venv for pip install (PEP 668); use setfacl for /dev/kvm - pyproject.toml: move psutil to optional [benchmarks] extra, out of base dependencies - README_DENSITY_RAMP.md: update JSON schema (vm_seq, density_at_boot, etc.) and fix failure-handling description - results/README.md: guard analysis snippet against empty boots list - v0_review_density_ramp_report.md: correct boot_time_s as end-to-end SSH readiness; clarify --socket-dir for fc_socket_count - v0_density_estimation_benchmark.md: fix malformed code fence; add VM cleanup to example Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/bench_command_latency.py | 37 +++++++---- benchmarks/bench_file_io.py | 29 ++++++--- benchmarks/bench_network_io.py | 43 +++++++++---- benchmarks/density_ramp.py | 61 +++++++++++-------- benchmarks/docs/README_DENSITY_RAMP.md | 27 +++++--- .../docs/v0_density_estimation_benchmark.md | 30 +++++---- .../docs/v0_review_density_ramp_report.md | 12 ++-- benchmarks/helpers.py | 8 ++- benchmarks/results/README.md | 14 +++-- benchmarks/run_density_ramp_ec2.sh | 41 ++++++++----- benchmarks/run_density_ramp_gcp.sh | 27 +++++--- pyproject.toml | 4 +- src/smolvm/build.py | 15 ++++- 13 files changed, 233 insertions(+), 115 deletions(-) diff --git a/benchmarks/bench_command_latency.py b/benchmarks/bench_command_latency.py index 4a1a90a..98ed3fd 100644 --- a/benchmarks/bench_command_latency.py +++ b/benchmarks/bench_command_latency.py @@ -7,17 +7,30 @@ import subprocess import sys -from helpers import ( - format_stats, - is_sandbox_exec_available, - overhead_str, - print_header, - print_result, - print_subheader, - run_sandboxed, - stats_summary, - time_call_n, -) +try: + from .helpers import ( + format_stats, + is_sandbox_exec_available, + overhead_str, + print_header, + print_result, + print_subheader, + run_sandboxed, + stats_summary, + time_call_n, + ) +except ImportError: + from helpers import ( # type: ignore[no-redef] + format_stats, + is_sandbox_exec_available, + overhead_str, + print_header, + print_result, + print_subheader, + run_sandboxed, + stats_summary, + time_call_n, + ) ITERATIONS = 100 WARMUP = 2 @@ -127,6 +140,4 @@ def _vm_echo(): if __name__ == "__main__": - if "benchmarks" in __file__: - sys.path.insert(0, str(__import__("pathlib").Path(__file__).parent)) run_benchmark() diff --git a/benchmarks/bench_file_io.py b/benchmarks/bench_file_io.py index d22ba2a..bc6e3a7 100644 --- a/benchmarks/bench_file_io.py +++ b/benchmarks/bench_file_io.py @@ -11,15 +11,26 @@ import sys import tempfile -from helpers import ( - format_stats, - overhead_str, - print_header, - print_result, - print_subheader, - stats_summary, - time_call, -) +try: + from .helpers import ( + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, + ) +except ImportError: + from helpers import ( # type: ignore[no-redef] + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, + ) # A 1KB line simulating a JSONL event _1KB_LINE = '{"ts":1234567890,"event":"prompt","session":"abc123","data":' + '"x' * 470 + '"}\n' diff --git a/benchmarks/bench_network_io.py b/benchmarks/bench_network_io.py index 2cac573..272919e 100644 --- a/benchmarks/bench_network_io.py +++ b/benchmarks/bench_network_io.py @@ -13,16 +13,28 @@ import threading import time -from helpers import ( - format_stats, - overhead_str, - print_header, - print_result, - print_subheader, - stats_summary, - time_call, - timer, -) +try: + from .helpers import ( + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, + timer, + ) +except ImportError: + from helpers import ( # type: ignore[no-redef] + format_stats, + overhead_str, + print_header, + print_result, + print_subheader, + stats_summary, + time_call, + timer, + ) def _find_free_port() -> int: @@ -133,8 +145,15 @@ def run_benchmark() -> dict: # Install curl in the VM print(" Installing curl in VM...") vm.run("apk add --no-cache curl 2>/dev/null || true", timeout=60) - curl_check = vm.run("which curl") - has_curl = "curl" in curl_check.stdout + curl_check = vm.run("which curl 2>/dev/null || which wget 2>/dev/null || echo 'none'") + has_curl = "curl" in curl_check.stdout and "none" not in curl_check.stdout + has_wget = "wget" in curl_check.stdout and "none" not in curl_check.stdout + + if not has_curl and not has_wget: + raise RuntimeError( + "VM has no HTTP client (curl or wget) and apk install failed; " + "cannot run network benchmark." + ) # Get the VM's gateway IP gateway_result = vm.run("ip route | grep default | awk '{print $3}'") diff --git a/benchmarks/density_ramp.py b/benchmarks/density_ramp.py index 417c24b..ab61d48 100644 --- a/benchmarks/density_ramp.py +++ b/benchmarks/density_ramp.py @@ -60,7 +60,12 @@ def snapshot(cls, vms_running: int, socket_dir: Path) -> "Metrics": ts = time.time() cpu = psutil.cpu_percent(interval=0.1) mem = psutil.virtual_memory().used / (1024**3) - disk = psutil.disk_usage(str(Path.home())).used / (1024**3) + # Measure the filesystem that actually holds SmolVM disk clones and images. + # On EC2 this is /mnt/nvme (symlinked from ~/.local/state/smolvm); fall back + # to the home filesystem when the SmolVM state dir doesn't exist yet. + _smolvm_state = Path.home() / ".local" / "state" / "smolvm" + _disk_probe = _smolvm_state if _smolvm_state.exists() else Path.home() + disk = psutil.disk_usage(str(_disk_probe.resolve())).used / (1024**3) # Count live Firecracker API sockets (accurate VM count proxy) fc_sockets = len(list(socket_dir.glob("fc-*.sock"))) @@ -102,13 +107,13 @@ def snapshot(cls, vms_running: int, socket_dir: Path) -> "Metrics": def cleanup() -> float: - """Stop all running VMs; return elapsed teardown seconds.""" + """Delete all running VMs; return elapsed teardown seconds.""" start = time.time() for vm in running_vms: try: - vm.stop() - except Exception: - pass + vm.delete() + except Exception as exc: + print(f"WARNING: failed to delete VM {getattr(vm, 'vm_id', '?')}: {exc}") return time.time() - start @@ -182,7 +187,7 @@ def boot_one( fc_log = _read_vm_log(vm) if vm is not None else "(VM object not created)" if vm is not None: try: - vm.stop() + vm.delete() except Exception: pass return None, time.time() - start_t, {"error": str(e), "fc_log": fc_log} @@ -255,7 +260,9 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: # Warn about disk usage in isolated mode if disk_mode == "isolated": est_disk_gb = (args.max_attempts * tier_config["disk_size_mib"]) / 1024 - free_gb = psutil.disk_usage(str(Path.home())).free / (1024**3) + _smolvm_state = Path.home() / ".local" / "state" / "smolvm" + _disk_probe = _smolvm_state if _smolvm_state.exists() else Path.home() + free_gb = psutil.disk_usage(str(_disk_probe.resolve())).free / (1024**3) print( f"INFO: isolated mode — up to {est_disk_gb:.0f} GB disk needed; " f"{free_gb:.1f} GB free on home filesystem." @@ -276,20 +283,23 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: while i < args.max_attempts: batch_size = min(args.parallel, args.max_attempts - i) - # Boot one batch (serial or parallel) + # Boot one batch (serial or parallel). + # Each result is a 4-tuple (vm, boot_t, err, snap) where snap is + # captured immediately when the boot completes — not post-batch — + # so parallel runs record per-VM resource state accurately. if batch_size == 1: - batch_results = [ - boot_one( - i + 1, - kernel, - rootfs, - ssh_key_path, - tier_config, - disk_mode, - args.backend, - args.socket_dir, - ) - ] + vm, boot_t, err = boot_one( + i + 1, + kernel, + rootfs, + ssh_key_path, + tier_config, + disk_mode, + args.backend, + args.socket_dir, + ) + density = len(running_vms) + (1 if vm is not None else 0) + batch_results = [(vm, boot_t, err, Metrics.snapshot(density, args.socket_dir))] else: with ThreadPoolExecutor(max_workers=batch_size) as ex: futures = [ @@ -306,13 +316,16 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: ) for j in range(batch_size) ] - batch_results = [f.result() for f in as_completed(futures)] + batch_results = [] + for f in as_completed(futures): + vm, boot_t, err = f.result() + density = len(running_vms) + (1 if vm is not None else 0) + snap = Metrics.snapshot(density, args.socket_dir) + batch_results.append((vm, boot_t, err, snap)) failed_this_batch = 0 - for vm, boot_t, err in batch_results: + for vm, boot_t, err, snap in batch_results: i += 1 - density = len(running_vms) + (1 if vm is not None else 0) - snap = Metrics.snapshot(density, args.socket_dir) if vm is not None: running_vms.append(vm) diff --git a/benchmarks/docs/README_DENSITY_RAMP.md b/benchmarks/docs/README_DENSITY_RAMP.md index d57e1af..419c1ce 100644 --- a/benchmarks/docs/README_DENSITY_RAMP.md +++ b/benchmarks/docs/README_DENSITY_RAMP.md @@ -105,13 +105,13 @@ Each tier defines VM memory and disk size: - Boot it and wait for SSH to become ready (up to 30 s) - Record boot time (includes SSH readiness — this is the true "ready to serve" latency) - Keep it running with the SSH connection pre-established (append to active VM list) - - Capture host metrics (CPU, memory, Firecracker RSS, KVM VM count) + - Capture host metrics (CPU, memory, disk, Firecracker RSS, TAP count, socket count) 2. **Sustain Check**: After the ramp completes (or hits `--max-attempts`), wait `--sustain-sec` seconds then run a liveness check (`uptime`) on all surviving VMs. Because SSH connections are pre-established during boot, the sustain check reuses existing paramiko transports rather than opening 64+ new connections concurrently. -3. **Failure Handling**: If any VM fails to boot, the batch is considered failed and the ramp stops. +3. **Failure Handling**: If an **entire batch** fails to boot, the ramp stops. A single failure within a larger batch does not halt the run. -4. **Cleanup**: On exit (success, failure, or interrupt), all VMs are stopped gracefully. +4. **Cleanup**: On exit (success, failure, or interrupt), all VMs are deleted gracefully. ## Output Format @@ -121,26 +121,37 @@ Results are written to a JSON file (default: `density.json`). Each entry represe [ { "event": "boot_ok", - "seq": 1, + "vm_seq": 1, "boot_time_s": 0.45, + "density_at_boot": 1, "timestamp": 1699564800.123, "vms_running": 1, "host_cpu_pct": 12.5, "host_mem_used_gb": 2.3, - "kvm_vms": 1, - "firecracker_rss_mb": 156.2 + "host_disk_used_gb": 2.1, + "tap_count": 1, + "firecracker_rss_mb": 46.9, + "fc_socket_count": 1, + "sqlite_db_kb": 52.0 }, { "event": "boot_fail", - "seq": 245, + "vm_seq": 245, "error": "Out of memory", "timestamp": 1699564900.456 }, { "event": "sustain_check", + "sustain_sec": 60, "vms_checked": 244, "vms_alive": 244, + "vms_dead": [], "timestamp": 1699564960.789 + }, + { + "event": "teardown", + "teardown_time_s": 45.2, + "timestamp": 1699565010.0 } ] ``` @@ -149,7 +160,7 @@ Results are written to a JSON file (default: `density.json`). Each entry represe - Linux system with KVM support (`/dev/kvm` accessible) - Python 3.10+ -- SmolVM installed: `pip install smolvm psutil` +- SmolVM installed: `pip install smolvm[benchmarks]` - Docker (for building the Alpine SSH image on first run) - `nftables` (`nft` command) for VM networking - Firecracker binary (downloaded automatically via `smolvm.host.HostManager().install_firecracker()`) diff --git a/benchmarks/docs/v0_density_estimation_benchmark.md b/benchmarks/docs/v0_density_estimation_benchmark.md index a286182..12721a0 100644 --- a/benchmarks/docs/v0_density_estimation_benchmark.md +++ b/benchmarks/docs/v0_density_estimation_benchmark.md @@ -10,19 +10,27 @@ SmolVM: Firecracker/KVM backend, ~572ms boot, low overhead. Firecracker hits 100 1. Density (Max VMs) Local Test First (your host equiv Ryzen 7): -```from smolvm import SmolVM +```python +from smolvm import SmolVM vms = [] i = 0 -while True: - try: - vm = SmolVM(mem_size_mib=128, disk_size_mib=512) # Minimal - vm.start() - vms.append(vm) - i += 1 - print(f"VM {i} OK") - except Exception as e: - print(f"Max: {i}, Fail: {e}") - break +try: + while True: + try: + vm = SmolVM(mem_size_mib=128, disk_size_mib=512) # Minimal + vm.start() + vms.append(vm) + i += 1 + print(f"VM {i} OK") + except Exception as e: + print(f"Max: {i}, Fail: {e}") + break +finally: + for vm in vms: + try: + vm.delete() + except Exception: + pass ``` Ramp until OOM/KVM slots (~host vCPUs). diff --git a/benchmarks/docs/v0_review_density_ramp_report.md b/benchmarks/docs/v0_review_density_ramp_report.md index 1326a4d..92b0037 100644 --- a/benchmarks/docs/v0_review_density_ramp_report.md +++ b/benchmarks/docs/v0_review_density_ramp_report.md @@ -22,10 +22,12 @@ three terminal conditions is reached: limit of SmolVM's IP pool) is hit before failure. - **The user interrupts** — `finally` ensures cleanup regardless. -Each boot is timed from `SmolVM(config).start()` call to return. The sequence number at -which each VM was booted (`density_at_boot`) is recorded alongside the boot time, so a -plot of `boot_time_s` vs `density_at_boot` shows whether boot latency degrades under -load. +Each boot is timed end-to-end: from `SmolVM(config)` construction through `vm.start()` +and `vm.wait_for_ssh(timeout=30.0)`. `boot_time_s` therefore represents the true +"ready to serve" latency — the time until SSH is responsive, not just until the +Firecracker process starts. The sequence number at which each VM was booted +(`density_at_boot`) is recorded alongside the boot time, so a plot of `boot_time_s` vs +`density_at_boot` shows whether boot latency degrades under load. The three tiers define the per-VM footprint: @@ -62,7 +64,7 @@ At every boot event and at the sustain/teardown checkpoints, the following are r | `host_disk_used_gb` | `psutil.disk_usage(home).used` | Tracks rootfs clone growth in isolated mode; should recover after teardown | | `host_cpu_pct` | `psutil.cpu_percent(interval=0.1)` | Transient boot-time CPU; sustained high values indicate host saturation | | `tap_count` | `ip -o link show \| grep tap` | Each Firecracker VM owns one TAP device; should equal `vms_running` | -| `fc_socket_count` | `glob("/tmp/fc-*.sock")` | Number of live Firecracker API sockets; cross-checks `vms_running` | +| `fc_socket_count` | `glob("/fc-*.sock")` | Live FC API sockets; cross-checks `vms_running`. Dir: `--socket-dir` | | `firecracker_rss_mb` | Sum of RSS for all `firecracker` PIDs | Hypervisor overhead per VM independent of guest memory allocation | | `sqlite_db_kb` | `stat(~/.local/state/smolvm/smolvm.db)` | State DB grows with each VM record; large size risks lock contention | diff --git a/benchmarks/helpers.py b/benchmarks/helpers.py index ff20255..42a0e8b 100644 --- a/benchmarks/helpers.py +++ b/benchmarks/helpers.py @@ -35,9 +35,11 @@ def timer(): """ t = _TimerResult() t.start = time.perf_counter() - yield t - t.end = time.perf_counter() - t.elapsed_ms = (t.end - t.start) * 1000.0 + try: + yield t + finally: + t.end = time.perf_counter() + t.elapsed_ms = (t.end - t.start) * 1000.0 class _TimerResult: diff --git a/benchmarks/results/README.md b/benchmarks/results/README.md index 340d38c..304457f 100644 --- a/benchmarks/results/README.md +++ b/benchmarks/results/README.md @@ -169,13 +169,17 @@ fails = [d for d in data if d["event"] == "boot_fail"] sustain = next((d for d in data if d["event"] == "sustain_check"), None) teardown = next((d for d in data if d["event"] == "teardown"), None) -times = [d["boot_time_s"] for d in boots] print(f"Peak VMs : {len(boots)}") print(f"Failed boots : {len(fails)}") -print(f"Avg boot time : {sum(times)/len(times):.2f}s") -print(f"Max boot time : {max(times):.2f}s") -print(f"Peak mem used : {boots[-1]['host_mem_used_gb']:.2f} GB") -print(f"RSS per VM : {boots[-1]['firecracker_rss_mb'] / len(boots):.1f} MB") +if boots: + times = [d["boot_time_s"] for d in boots] + print(f"Avg boot time : {sum(times)/len(times):.2f}s") + print(f"Max boot time : {max(times):.2f}s") + print(f"Peak mem used : {boots[-1]['host_mem_used_gb']:.2f} GB") + print(f"RSS per VM : {boots[-1]['firecracker_rss_mb'] / len(boots):.1f} MB") +else: + if fails: + print(f"First failure : {fails[0].get('error', '?')}") if sustain: print(f"Sustain result : {sustain['vms_alive']}/{sustain['vms_checked']} alive") if teardown: diff --git a/benchmarks/run_density_ramp_ec2.sh b/benchmarks/run_density_ramp_ec2.sh index 4e1f4b7..92c6b5a 100755 --- a/benchmarks/run_density_ramp_ec2.sh +++ b/benchmarks/run_density_ramp_ec2.sh @@ -30,7 +30,7 @@ set -euo pipefail # --------------------------------------------------------------------------- REGION="${REGION:-us-east-2}" INSTANCE_TYPE="${INSTANCE_TYPE:-c5d.metal}" -KEY_NAME="smolvm-benchmark" #"${KEY_NAME:-}" +KEY_NAME="${KEY_NAME:-smolvm-benchmark}" KEY_PATH="${KEY_PATH:-}" SECURITY_GROUP="${SECURITY_GROUP:-}" SUBNET_ID="${SUBNET_ID:-}" @@ -120,13 +120,22 @@ if [[ -z "$SECURITY_GROUP" ]]; then --query "GroupId" \ --output text) - # Allow SSH from anywhere (scope this down if your environment allows it) + # Allow SSH only from the caller's public IP + CALLER_IP=$(curl -sf https://checkip.amazonaws.com 2>/dev/null \ + || curl -sf https://ifconfig.me 2>/dev/null \ + || echo "") + if [[ -n "$CALLER_IP" ]]; then + SSH_CIDR="${CALLER_IP}/32" + else + echo "WARNING: could not determine public IP; opening SSH to 0.0.0.0/0" + SSH_CIDR="0.0.0.0/0" + fi aws ec2 authorize-security-group-ingress \ --region "$REGION" \ --group-id "$SECURITY_GROUP" \ --protocol tcp \ --port 22 \ - --cidr 0.0.0.0/0 \ + --cidr "$SSH_CIDR" \ >/dev/null CREATED_SG="$SECURITY_GROUP" @@ -265,17 +274,21 @@ sudo dnf install -y python3.11 python3.11-pip docker nftables --quiet sudo systemctl start docker sudo usermod -aG docker ec2-user -# Mount NVMe instance store and redirect all smolvm data to it -sudo mkfs.ext4 -F /dev/nvme1n1 -sudo mkdir -p /mnt/nvme -sudo mount /dev/nvme1n1 /mnt/nvme -sudo mkdir -p /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state -sudo chown ec2-user:ec2-user /mnt/nvme /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state -# Image cache (~/.smolvm/images/) → NVMe -ln -sfn /mnt/nvme/smolvm-images /home/ec2-user/.smolvm -# Disk clones (~/.local/state/smolvm/disks/) → NVMe -mkdir -p /home/ec2-user/.local/state -ln -sfn /mnt/nvme/smolvm-state /home/ec2-user/.local/state/smolvm +# Mount NVMe instance store and redirect all smolvm data to it (if present) +if test -b /dev/nvme1n1; then + sudo mkfs.ext4 -F /dev/nvme1n1 + sudo mkdir -p /mnt/nvme + sudo mount /dev/nvme1n1 /mnt/nvme + sudo mkdir -p /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state + sudo chown ec2-user:ec2-user /mnt/nvme /mnt/nvme/smolvm-images /mnt/nvme/smolvm-state + # Image cache (~/.smolvm/images/) → NVMe + ln -sfn /mnt/nvme/smolvm-images /home/ec2-user/.smolvm + # Disk clones (~/.local/state/smolvm/disks/) → NVMe + mkdir -p /home/ec2-user/.local/state + ln -sfn /mnt/nvme/smolvm-state /home/ec2-user/.local/state/smolvm +else + echo "WARNING: /dev/nvme1n1 not found; using root volume for SmolVM data." +fi REMOTE scp -i "$KEY_PATH" -o StrictHostKeyChecking=no \ diff --git a/benchmarks/run_density_ramp_gcp.sh b/benchmarks/run_density_ramp_gcp.sh index ed51ca3..8f03759 100755 --- a/benchmarks/run_density_ramp_gcp.sh +++ b/benchmarks/run_density_ramp_gcp.sh @@ -80,13 +80,23 @@ CREATED_FIREWALL_RULE="" if [[ -z "$FIREWALL_RULE" ]]; then FIREWALL_RULE="$NETWORK_TAG-ssh" - echo "Creating temporary firewall rule $FIREWALL_RULE..." + # Restrict SSH to the caller's public IP + CALLER_IP=$(curl -sf https://ifconfig.me 2>/dev/null \ + || curl -sf https://checkip.amazonaws.com 2>/dev/null \ + || echo "") + if [[ -n "$CALLER_IP" ]]; then + SSH_SOURCE_RANGE="${CALLER_IP}/32" + else + echo "WARNING: could not determine public IP; opening SSH to 0.0.0.0/0" + SSH_SOURCE_RANGE="0.0.0.0/0" + fi + echo "Creating temporary firewall rule $FIREWALL_RULE (source: $SSH_SOURCE_RANGE)..." gcloud compute firewall-rules create "$FIREWALL_RULE" \ --project="$PROJECT" \ --direction=INGRESS \ --action=ALLOW \ --rules=tcp:22 \ - --source-ranges=0.0.0.0/0 \ + --source-ranges="$SSH_SOURCE_RANGE" \ --target-tags="$NETWORK_TAG" \ --quiet CREATED_FIREWALL_RULE="$FIREWALL_RULE" @@ -200,17 +210,18 @@ set -euo pipefail # Enable KVM access sudo usermod -aG kvm "$USER" || true -sudo chmod 666 /dev/kvm +sudo setfacl -m u:"$USER":rw /dev/kvm 2>/dev/null || sudo chmod 666 /dev/kvm # Install Python and pip sudo apt-get update -qq -sudo apt-get install -y -qq python3 python3-pip +sudo apt-get install -y -qq python3 python3-pip python3-venv -# Install smolvm and psutil -pip3 install --quiet smolvm psutil +# Install smolvm and psutil into a venv (avoids PEP 668 externally-managed-env error) +python3 -m venv ~/venv +~/venv/bin/pip install --quiet smolvm psutil # Trigger Firecracker binary download -smolvm demo list 2>/dev/null || true +~/venv/bin/smolvm demo list 2>/dev/null || true REMOTE echo "Dependencies installed." @@ -230,7 +241,7 @@ echo "Uploaded density_ramp.py" # Run benchmark # --------------------------------------------------------------------------- REMOTE_OUTPUT="density.json" -BENCHMARK_CMD="python3 ~/density_ramp.py \ +BENCHMARK_CMD="~/venv/bin/python ~/density_ramp.py \ --tier $TIER \ --max-attempts $MAX_ATTEMPTS \ --sustain-sec $SUSTAIN_SEC \ diff --git a/pyproject.toml b/pyproject.toml index 60587e0..e479223 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,13 +28,15 @@ classifiers = [ ] dependencies = [ "paramiko>=3.0", - "psutil>=7.2.2", "pydantic>=2.0", "requests>=2.28", "requests-unixsocket>=0.3", ] [project.optional-dependencies] +benchmarks = [ + "psutil>=7.2.2", +] dev = [ "pytest>=7.0", "pytest-cov>=4.0", diff --git a/src/smolvm/build.py b/src/smolvm/build.py index ab07dc9..e472108 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -974,7 +974,7 @@ def _create_ext4_with_docker( """ logger.info(" [3/4] Creating ext4 filesystem via Docker helper (%dMB)...", rootfs_size_mb) - # Security check: scan tar member paths before Docker extracts them. + # Security check: scan tar member paths and link targets before Docker extracts them. with tarfile.open(tar_path, "r") as tar: for member in tar.getmembers(): member_path = Path(member.name) @@ -982,6 +982,13 @@ def _create_ext4_with_docker( raise ImageError( f"Refusing to extract suspicious tar path from docker export: {member.name}" ) + if member.issym() or member.islnk(): + link_path = Path(member.linkname) + if link_path.is_absolute() or ".." in link_path.parts: + raise ImageError( + "Refusing to extract suspicious tar link from docker export: " + f"{member.name} -> {member.linkname}" + ) # Let Docker (running as root) extract the tarball and build the ext4 # image in a single pass. This preserves the correct uid/gid for every @@ -995,6 +1002,7 @@ def _create_ext4_with_docker( rootfs_path.unlink(missing_ok=True) rootfs_name = shlex.quote(rootfs_path.name) tar_name = shlex.quote(tar_path.name) + uid, gid = os.getuid(), os.getgid() shell_cmd = ( "set -e; " "apk add --no-cache e2fsprogs >/dev/null; " @@ -1005,7 +1013,10 @@ def _create_ext4_with_docker( "chown root:root /work/rootfs/var/empty 2>/dev/null || true; " "chmod 755 /work/rootfs/var/empty 2>/dev/null || true; " f"mke2fs -d /work/rootfs -t ext4 -F /work/out/{rootfs_name} " - f"{rootfs_size_mb}M >/dev/null" + f"{rootfs_size_mb}M >/dev/null; " + # Restore ownership of the output file so the calling (non-root) user + # can read, cache, and clean up the ext4 image on Linux with rootful Docker. + f"chown {uid}:{gid} /work/out/{rootfs_name} 2>/dev/null || true" ) try: From b002fb878c57165c908c63099008eb91b1fff5f6 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:17:14 -0400 Subject: [PATCH 14/20] fix: bench_file_io bulk read uses dd to /dev/null, not cat cat /tmp/bench_read.dat measures SSH/stdout transport (~10MB through the command channel) rather than guest disk I/O, making the VM vs host comparison misleading. Use dd if=... of=/dev/null so only the guest filesystem read is timed. Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/bench_file_io.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/benchmarks/bench_file_io.py b/benchmarks/bench_file_io.py index bc6e3a7..cdb67c5 100644 --- a/benchmarks/bench_file_io.py +++ b/benchmarks/bench_file_io.py @@ -163,13 +163,15 @@ def run_benchmark() -> dict: print_result("Stats", format_stats(vm_bulk_w_stats)) results["vm_bulk_write"] = vm_bulk_w_stats - # Bulk read reading via vm.run("cat ...") - print_subheader("SmolVM: Bulk read (~10MB via cat)") + # Bulk read: use dd to /dev/null so only guest disk I/O is measured, + # not SSH/stdout transport overhead (cat would send ~10 MB through the + # command channel, distorting the result vs the host baseline). + print_subheader("SmolVM: Bulk read (~10MB, guest disk only)") # First ensure the file exists vm.run("dd if=/dev/zero of=/tmp/bench_read.dat bs=1024 count=10240 2>/dev/null", timeout=60) vm_bulk_r_times = [] for _ in range(3): - t = time_call(lambda: vm.run("cat /tmp/bench_read.dat", timeout=60)) + t = time_call(lambda: vm.run("dd if=/tmp/bench_read.dat of=/dev/null bs=1024 2>/dev/null", timeout=60)) vm_bulk_r_times.append(t) vm_bulk_r_stats = stats_summary(vm_bulk_r_times) print_result("Stats", format_stats(vm_bulk_r_stats)) From 4570006f04b26b914a28a90303defa88688550bc Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:26:37 -0400 Subject: [PATCH 15/20] moved results file to dir --- benchmarks/density_20260309_010721.json | 3830 ----------------------- 1 file changed, 3830 deletions(-) delete mode 100644 benchmarks/density_20260309_010721.json diff --git a/benchmarks/density_20260309_010721.json b/benchmarks/density_20260309_010721.json deleted file mode 100644 index b5497cf..0000000 --- a/benchmarks/density_20260309_010721.json +++ /dev/null @@ -1,3830 +0,0 @@ -[ - { - "event": "meta", - "note": "re-tested after rebase" - }, - { - "event": "boot_ok", - "vm_seq": 1, - "boot_time_s": 3.557, - "density_at_boot": 1, - "timestamp": 1773033027.8439739, - "vms_running": 1, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 2.7269515991210938, - "host_disk_used_gb": 2.0351943969726562, - "tap_count": 1, - "firecracker_rss_mb": 47.4375, - "fc_socket_count": 1, - "sqlite_db_kb": 52.0 - }, - { - "event": "boot_ok", - "vm_seq": 2, - "boot_time_s": 3.012, - "density_at_boot": 2, - "timestamp": 1773033031.0415125, - "vms_running": 2, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 2.7830047607421875, - "host_disk_used_gb": 2.0351943969726562, - "tap_count": 2, - "firecracker_rss_mb": 94.62109375, - "fc_socket_count": 2, - "sqlite_db_kb": 52.0 - }, - { - "event": "boot_ok", - "vm_seq": 3, - "boot_time_s": 2.976, - "density_at_boot": 3, - "timestamp": 1773033034.1608803, - "vms_running": 3, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 2.8303489685058594, - "host_disk_used_gb": 2.0352554321289062, - "tap_count": 3, - "firecracker_rss_mb": 141.55078125, - "fc_socket_count": 3, - "sqlite_db_kb": 52.0 - }, - { - "event": "boot_ok", - "vm_seq": 4, - "boot_time_s": 3.058, - "density_at_boot": 4, - "timestamp": 1773033037.361834, - "vms_running": 4, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 2.877735137939453, - "host_disk_used_gb": 2.0352554321289062, - "tap_count": 4, - "firecracker_rss_mb": 188.73828125, - "fc_socket_count": 4, - "sqlite_db_kb": 52.0 - }, - { - "event": "boot_ok", - "vm_seq": 5, - "boot_time_s": 3.218, - "density_at_boot": 5, - "timestamp": 1773033040.722996, - "vms_running": 5, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 2.936298370361328, - "host_disk_used_gb": 2.0353164672851562, - "tap_count": 5, - "firecracker_rss_mb": 235.14453125, - "fc_socket_count": 5, - "sqlite_db_kb": 52.0 - }, - { - "event": "boot_ok", - "vm_seq": 6, - "boot_time_s": 2.977, - "density_at_boot": 6, - "timestamp": 1773033043.8448167, - "vms_running": 6, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 2.993610382080078, - "host_disk_used_gb": 2.0353164672851562, - "tap_count": 6, - "firecracker_rss_mb": 282.84765625, - "fc_socket_count": 6, - "sqlite_db_kb": 60.0 - }, - { - "event": "boot_ok", - "vm_seq": 7, - "boot_time_s": 2.973, - "density_at_boot": 7, - "timestamp": 1773033046.962404, - "vms_running": 7, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.0497703552246094, - "host_disk_used_gb": 2.0353775024414062, - "tap_count": 7, - "firecracker_rss_mb": 330.29296875, - "fc_socket_count": 7, - "sqlite_db_kb": 60.0 - }, - { - "event": "boot_ok", - "vm_seq": 8, - "boot_time_s": 2.117, - "density_at_boot": 8, - "timestamp": 1773033049.2229445, - "vms_running": 8, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.100330352783203, - "host_disk_used_gb": 2.0353775024414062, - "tap_count": 8, - "firecracker_rss_mb": 377.22265625, - "fc_socket_count": 8, - "sqlite_db_kb": 60.0 - }, - { - "event": "boot_ok", - "vm_seq": 9, - "boot_time_s": 3.035, - "density_at_boot": 9, - "timestamp": 1773033052.4030461, - "vms_running": 9, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.1607666015625, - "host_disk_used_gb": 2.0354385375976562, - "tap_count": 9, - "firecracker_rss_mb": 424.40625, - "fc_socket_count": 9, - "sqlite_db_kb": 60.0 - }, - { - "event": "boot_ok", - "vm_seq": 10, - "boot_time_s": 3.054, - "density_at_boot": 10, - "timestamp": 1773033055.6033888, - "vms_running": 10, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 3.2168922424316406, - "host_disk_used_gb": 2.0354385375976562, - "tap_count": 10, - "firecracker_rss_mb": 470.81640625, - "fc_socket_count": 10, - "sqlite_db_kb": 60.0 - }, - { - "event": "boot_ok", - "vm_seq": 11, - "boot_time_s": 2.973, - "density_at_boot": 11, - "timestamp": 1773033058.7229776, - "vms_running": 11, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.2730178833007812, - "host_disk_used_gb": 2.0354995727539062, - "tap_count": 11, - "firecracker_rss_mb": 517.48046875, - "fc_socket_count": 11, - "sqlite_db_kb": 64.0 - }, - { - "event": "boot_ok", - "vm_seq": 12, - "boot_time_s": 2.97, - "density_at_boot": 12, - "timestamp": 1773033061.8406522, - "vms_running": 12, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.3240890502929688, - "host_disk_used_gb": 2.0354995727539062, - "tap_count": 12, - "firecracker_rss_mb": 564.671875, - "fc_socket_count": 12, - "sqlite_db_kb": 64.0 - }, - { - "event": "boot_ok", - "vm_seq": 13, - "boot_time_s": 2.975, - "density_at_boot": 13, - "timestamp": 1773033064.9625804, - "vms_running": 13, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.38525390625, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 13, - "firecracker_rss_mb": 612.37109375, - "fc_socket_count": 13, - "sqlite_db_kb": 64.0 - }, - { - "event": "boot_ok", - "vm_seq": 14, - "boot_time_s": 2.053, - "density_at_boot": 14, - "timestamp": 1773033067.1609247, - "vms_running": 14, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.4327239990234375, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 14, - "firecracker_rss_mb": 660.078125, - "fc_socket_count": 14, - "sqlite_db_kb": 64.0 - }, - { - "event": "boot_ok", - "vm_seq": 15, - "boot_time_s": 2.075, - "density_at_boot": 15, - "timestamp": 1773033069.3810976, - "vms_running": 15, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.485340118408203, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 15, - "firecracker_rss_mb": 707.0, - "fc_socket_count": 15, - "sqlite_db_kb": 64.0 - }, - { - "event": "boot_ok", - "vm_seq": 16, - "boot_time_s": 1.971, - "density_at_boot": 16, - "timestamp": 1773033071.4986103, - "vms_running": 16, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 3.5328598022460938, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 16, - "firecracker_rss_mb": 754.95703125, - "fc_socket_count": 16, - "sqlite_db_kb": 68.0 - }, - { - "event": "boot_ok", - "vm_seq": 17, - "boot_time_s": 2.139, - "density_at_boot": 17, - "timestamp": 1773033073.7816103, - "vms_running": 17, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.590251922607422, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 17, - "firecracker_rss_mb": 801.8828125, - "fc_socket_count": 17, - "sqlite_db_kb": 68.0 - }, - { - "event": "boot_ok", - "vm_seq": 18, - "boot_time_s": 2.993, - "density_at_boot": 18, - "timestamp": 1773033076.9206767, - "vms_running": 18, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.6424293518066406, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 18, - "firecracker_rss_mb": 848.80859375, - "fc_socket_count": 18, - "sqlite_db_kb": 68.0 - }, - { - "event": "boot_ok", - "vm_seq": 19, - "boot_time_s": 3.095, - "density_at_boot": 19, - "timestamp": 1773033080.1619146, - "vms_running": 19, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.6910667419433594, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 19, - "firecracker_rss_mb": 895.73828125, - "fc_socket_count": 19, - "sqlite_db_kb": 68.0 - }, - { - "event": "boot_ok", - "vm_seq": 20, - "boot_time_s": 2.93, - "density_at_boot": 20, - "timestamp": 1773033083.2386947, - "vms_running": 20, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 3.746997833251953, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 20, - "firecracker_rss_mb": 943.69921875, - "fc_socket_count": 20, - "sqlite_db_kb": 68.0 - }, - { - "event": "boot_ok", - "vm_seq": 21, - "boot_time_s": 2.239, - "density_at_boot": 21, - "timestamp": 1773033085.62172, - "vms_running": 21, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 3.7973709106445312, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 21, - "firecracker_rss_mb": 990.62890625, - "fc_socket_count": 21, - "sqlite_db_kb": 72.0 - }, - { - "event": "boot_ok", - "vm_seq": 22, - "boot_time_s": 3.034, - "density_at_boot": 22, - "timestamp": 1773033088.8028262, - "vms_running": 22, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 3.8506126403808594, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 22, - "firecracker_rss_mb": 1037.55078125, - "fc_socket_count": 22, - "sqlite_db_kb": 72.0 - }, - { - "event": "boot_ok", - "vm_seq": 23, - "boot_time_s": 2.17, - "density_at_boot": 23, - "timestamp": 1773033091.1226404, - "vms_running": 23, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.9020309448242188, - "host_disk_used_gb": 2.0359878540039062, - "tap_count": 23, - "firecracker_rss_mb": 1084.47265625, - "fc_socket_count": 23, - "sqlite_db_kb": 72.0 - }, - { - "event": "boot_ok", - "vm_seq": 24, - "boot_time_s": 3.054, - "density_at_boot": 24, - "timestamp": 1773033094.3238337, - "vms_running": 24, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.951507568359375, - "host_disk_used_gb": 2.0360107421875, - "tap_count": 24, - "firecracker_rss_mb": 1131.40234375, - "fc_socket_count": 24, - "sqlite_db_kb": 72.0 - }, - { - "event": "boot_ok", - "vm_seq": 25, - "boot_time_s": 3.051, - "density_at_boot": 25, - "timestamp": 1773033097.5225387, - "vms_running": 25, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 4.002567291259766, - "host_disk_used_gb": 2.035991668701172, - "tap_count": 25, - "firecracker_rss_mb": 1178.328125, - "fc_socket_count": 25, - "sqlite_db_kb": 72.0 - }, - { - "event": "boot_ok", - "vm_seq": 26, - "boot_time_s": 2.231, - "density_at_boot": 26, - "timestamp": 1773033099.9013627, - "vms_running": 26, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.061363220214844, - "host_disk_used_gb": 2.035991668701172, - "tap_count": 26, - "firecracker_rss_mb": 1225.76953125, - "fc_socket_count": 26, - "sqlite_db_kb": 76.0 - }, - { - "event": "boot_ok", - "vm_seq": 27, - "boot_time_s": 3.073, - "density_at_boot": 27, - "timestamp": 1773033103.1235607, - "vms_running": 27, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.113433837890625, - "host_disk_used_gb": 2.035991668701172, - "tap_count": 27, - "firecracker_rss_mb": 1272.69921875, - "fc_socket_count": 27, - "sqlite_db_kb": 76.0 - }, - { - "event": "boot_ok", - "vm_seq": 28, - "boot_time_s": 3.128, - "density_at_boot": 28, - "timestamp": 1773033106.4006462, - "vms_running": 28, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.165180206298828, - "host_disk_used_gb": 2.035991668701172, - "tap_count": 28, - "firecracker_rss_mb": 1319.3671875, - "fc_socket_count": 28, - "sqlite_db_kb": 76.0 - }, - { - "event": "boot_ok", - "vm_seq": 29, - "boot_time_s": 3.056, - "density_at_boot": 29, - "timestamp": 1773033109.6045015, - "vms_running": 29, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.213230133056641, - "host_disk_used_gb": 2.036968231201172, - "tap_count": 29, - "firecracker_rss_mb": 1366.80859375, - "fc_socket_count": 29, - "sqlite_db_kb": 76.0 - }, - { - "event": "boot_ok", - "vm_seq": 30, - "boot_time_s": 3.051, - "density_at_boot": 30, - "timestamp": 1773033112.804648, - "vms_running": 30, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.257366180419922, - "host_disk_used_gb": 2.036968231201172, - "tap_count": 30, - "firecracker_rss_mb": 1413.48046875, - "fc_socket_count": 30, - "sqlite_db_kb": 76.0 - }, - { - "event": "boot_ok", - "vm_seq": 31, - "boot_time_s": 3.05, - "density_at_boot": 31, - "timestamp": 1773033116.0029683, - "vms_running": 31, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.305568695068359, - "host_disk_used_gb": 2.036968231201172, - "tap_count": 31, - "firecracker_rss_mb": 1460.40234375, - "fc_socket_count": 31, - "sqlite_db_kb": 80.0 - }, - { - "event": "boot_ok", - "vm_seq": 32, - "boot_time_s": 3.052, - "density_at_boot": 32, - "timestamp": 1773033119.2038808, - "vms_running": 32, - "host_cpu_pct": 0.5, - "host_mem_used_gb": 4.353710174560547, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 32, - "firecracker_rss_mb": 1507.328125, - "fc_socket_count": 32, - "sqlite_db_kb": 80.0 - }, - { - "event": "boot_ok", - "vm_seq": 33, - "boot_time_s": 3.13, - "density_at_boot": 33, - "timestamp": 1773033122.4816763, - "vms_running": 33, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 4.400493621826172, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 33, - "firecracker_rss_mb": 1554.2578125, - "fc_socket_count": 33, - "sqlite_db_kb": 80.0 - }, - { - "event": "boot_ok", - "vm_seq": 34, - "boot_time_s": 3.006, - "density_at_boot": 34, - "timestamp": 1773033125.6367514, - "vms_running": 34, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 4.442150115966797, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 34, - "firecracker_rss_mb": 1601.703125, - "fc_socket_count": 34, - "sqlite_db_kb": 80.0 - }, - { - "event": "boot_ok", - "vm_seq": 35, - "boot_time_s": 3.019, - "density_at_boot": 35, - "timestamp": 1773033128.801706, - "vms_running": 35, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.484050750732422, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 35, - "firecracker_rss_mb": 1648.6328125, - "fc_socket_count": 35, - "sqlite_db_kb": 80.0 - }, - { - "event": "boot_ok", - "vm_seq": 36, - "boot_time_s": 3.05, - "density_at_boot": 36, - "timestamp": 1773033132.0019503, - "vms_running": 36, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.5365753173828125, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 36, - "firecracker_rss_mb": 1695.5625, - "fc_socket_count": 36, - "sqlite_db_kb": 84.0 - }, - { - "event": "boot_ok", - "vm_seq": 37, - "boot_time_s": 3.048, - "density_at_boot": 37, - "timestamp": 1773033135.201699, - "vms_running": 37, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 4.581813812255859, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 37, - "firecracker_rss_mb": 1742.7421875, - "fc_socket_count": 37, - "sqlite_db_kb": 84.0 - }, - { - "event": "boot_ok", - "vm_seq": 38, - "boot_time_s": 3.051, - "density_at_boot": 38, - "timestamp": 1773033138.4028268, - "vms_running": 38, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.623851776123047, - "host_disk_used_gb": 2.0369720458984375, - "tap_count": 38, - "firecracker_rss_mb": 1789.671875, - "fc_socket_count": 38, - "sqlite_db_kb": 84.0 - }, - { - "event": "boot_ok", - "vm_seq": 39, - "boot_time_s": 3.051, - "density_at_boot": 39, - "timestamp": 1773033141.6038764, - "vms_running": 39, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.667224884033203, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 39, - "firecracker_rss_mb": 1836.34375, - "fc_socket_count": 39, - "sqlite_db_kb": 84.0 - }, - { - "event": "boot_ok", - "vm_seq": 40, - "boot_time_s": 3.047, - "density_at_boot": 40, - "timestamp": 1773033144.8007727, - "vms_running": 40, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.7087860107421875, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 40, - "firecracker_rss_mb": 1883.5234375, - "fc_socket_count": 40, - "sqlite_db_kb": 84.0 - }, - { - "event": "boot_ok", - "vm_seq": 41, - "boot_time_s": 3.051, - "density_at_boot": 41, - "timestamp": 1773033148.0039015, - "vms_running": 41, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 4.762592315673828, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 41, - "firecracker_rss_mb": 1930.19140625, - "fc_socket_count": 41, - "sqlite_db_kb": 88.0 - }, - { - "event": "boot_ok", - "vm_seq": 42, - "boot_time_s": 3.047, - "density_at_boot": 42, - "timestamp": 1773033151.2032633, - "vms_running": 42, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.809150695800781, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 42, - "firecracker_rss_mb": 1977.37890625, - "fc_socket_count": 42, - "sqlite_db_kb": 88.0 - }, - { - "event": "boot_ok", - "vm_seq": 43, - "boot_time_s": 3.048, - "density_at_boot": 43, - "timestamp": 1773033154.4018452, - "vms_running": 43, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.859760284423828, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 43, - "firecracker_rss_mb": 2024.8203125, - "fc_socket_count": 43, - "sqlite_db_kb": 88.0 - }, - { - "event": "boot_ok", - "vm_seq": 44, - "boot_time_s": 3.051, - "density_at_boot": 44, - "timestamp": 1773033157.601361, - "vms_running": 44, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.906074523925781, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 44, - "firecracker_rss_mb": 2071.4921875, - "fc_socket_count": 44, - "sqlite_db_kb": 88.0 - }, - { - "event": "boot_ok", - "vm_seq": 45, - "boot_time_s": 3.009, - "density_at_boot": 45, - "timestamp": 1773033160.7611601, - "vms_running": 45, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 4.957592010498047, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 45, - "firecracker_rss_mb": 2118.421875, - "fc_socket_count": 45, - "sqlite_db_kb": 88.0 - }, - { - "event": "boot_ok", - "vm_seq": 46, - "boot_time_s": 3.171, - "density_at_boot": 46, - "timestamp": 1773033164.0836096, - "vms_running": 46, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.002906799316406, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 46, - "firecracker_rss_mb": 2165.34765625, - "fc_socket_count": 46, - "sqlite_db_kb": 92.0 - }, - { - "event": "boot_ok", - "vm_seq": 47, - "boot_time_s": 3.046, - "density_at_boot": 47, - "timestamp": 1773033167.2820804, - "vms_running": 47, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.047607421875, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 47, - "firecracker_rss_mb": 2212.53515625, - "fc_socket_count": 47, - "sqlite_db_kb": 92.0 - }, - { - "event": "boot_ok", - "vm_seq": 48, - "boot_time_s": 3.047, - "density_at_boot": 48, - "timestamp": 1773033170.4816763, - "vms_running": 48, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.085933685302734, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 48, - "firecracker_rss_mb": 2259.46484375, - "fc_socket_count": 48, - "sqlite_db_kb": 92.0 - }, - { - "event": "boot_ok", - "vm_seq": 49, - "boot_time_s": 3.128, - "density_at_boot": 49, - "timestamp": 1773033173.761677, - "vms_running": 49, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.1317138671875, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 49, - "firecracker_rss_mb": 2306.13671875, - "fc_socket_count": 49, - "sqlite_db_kb": 92.0 - }, - { - "event": "boot_ok", - "vm_seq": 50, - "boot_time_s": 3.05, - "density_at_boot": 50, - "timestamp": 1773033176.9637046, - "vms_running": 50, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 5.177833557128906, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 50, - "firecracker_rss_mb": 2353.83984375, - "fc_socket_count": 50, - "sqlite_db_kb": 92.0 - }, - { - "event": "boot_ok", - "vm_seq": 51, - "boot_time_s": 3.046, - "density_at_boot": 51, - "timestamp": 1773033180.1613538, - "vms_running": 51, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 5.221309661865234, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 51, - "firecracker_rss_mb": 2400.51171875, - "fc_socket_count": 51, - "sqlite_db_kb": 96.0 - }, - { - "event": "boot_ok", - "vm_seq": 52, - "boot_time_s": 3.05, - "density_at_boot": 52, - "timestamp": 1773033183.3628714, - "vms_running": 52, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 5.270954132080078, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 52, - "firecracker_rss_mb": 2447.18359375, - "fc_socket_count": 52, - "sqlite_db_kb": 96.0 - }, - { - "event": "boot_ok", - "vm_seq": 53, - "boot_time_s": 2.111, - "density_at_boot": 53, - "timestamp": 1773033185.6233401, - "vms_running": 53, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.3211517333984375, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 53, - "firecracker_rss_mb": 2494.11328125, - "fc_socket_count": 53, - "sqlite_db_kb": 96.0 - }, - { - "event": "boot_ok", - "vm_seq": 54, - "boot_time_s": 3.024, - "density_at_boot": 54, - "timestamp": 1773033188.8009796, - "vms_running": 54, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 5.3712005615234375, - "host_disk_used_gb": 2.0447845458984375, - "tap_count": 54, - "firecracker_rss_mb": 2541.296875, - "fc_socket_count": 54, - "sqlite_db_kb": 96.0 - }, - { - "event": "boot_ok", - "vm_seq": 55, - "boot_time_s": 3.133, - "density_at_boot": 55, - "timestamp": 1773033192.0828273, - "vms_running": 55, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.407588958740234, - "host_disk_used_gb": 2.0448074340820312, - "tap_count": 55, - "firecracker_rss_mb": 2587.96484375, - "fc_socket_count": 55, - "sqlite_db_kb": 96.0 - }, - { - "event": "boot_ok", - "vm_seq": 56, - "boot_time_s": 3.007, - "density_at_boot": 56, - "timestamp": 1773033195.2397757, - "vms_running": 56, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.461029052734375, - "host_disk_used_gb": 2.0447463989257812, - "tap_count": 56, - "firecracker_rss_mb": 2635.40625, - "fc_socket_count": 56, - "sqlite_db_kb": 100.0 - }, - { - "event": "boot_ok", - "vm_seq": 57, - "boot_time_s": 3.012, - "density_at_boot": 57, - "timestamp": 1773033198.4022074, - "vms_running": 57, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.516471862792969, - "host_disk_used_gb": 2.0447463989257812, - "tap_count": 57, - "firecracker_rss_mb": 2682.5859375, - "fc_socket_count": 57, - "sqlite_db_kb": 100.0 - }, - { - "event": "boot_ok", - "vm_seq": 58, - "boot_time_s": 2.065, - "density_at_boot": 58, - "timestamp": 1773033200.6183062, - "vms_running": 58, - "host_cpu_pct": 0.5, - "host_mem_used_gb": 5.566684722900391, - "host_disk_used_gb": 2.0447463989257812, - "tap_count": 58, - "firecracker_rss_mb": 2730.546875, - "fc_socket_count": 58, - "sqlite_db_kb": 100.0 - }, - { - "event": "boot_ok", - "vm_seq": 59, - "boot_time_s": 2.995, - "density_at_boot": 59, - "timestamp": 1773033203.7625341, - "vms_running": 59, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.616291046142578, - "host_disk_used_gb": 2.0447463989257812, - "tap_count": 59, - "firecracker_rss_mb": 2777.98828125, - "fc_socket_count": 59, - "sqlite_db_kb": 100.0 - }, - { - "event": "boot_ok", - "vm_seq": 60, - "boot_time_s": 3.005, - "density_at_boot": 60, - "timestamp": 1773033206.9203105, - "vms_running": 60, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.656620025634766, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 60, - "firecracker_rss_mb": 2824.65234375, - "fc_socket_count": 60, - "sqlite_db_kb": 100.0 - }, - { - "event": "boot_ok", - "vm_seq": 61, - "boot_time_s": 2.968, - "density_at_boot": 61, - "timestamp": 1773033210.0405595, - "vms_running": 61, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.709175109863281, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 61, - "firecracker_rss_mb": 2871.06640625, - "fc_socket_count": 61, - "sqlite_db_kb": 112.0 - }, - { - "event": "boot_ok", - "vm_seq": 62, - "boot_time_s": 2.968, - "density_at_boot": 62, - "timestamp": 1773033213.160054, - "vms_running": 62, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.756771087646484, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 62, - "firecracker_rss_mb": 2917.48046875, - "fc_socket_count": 62, - "sqlite_db_kb": 112.0 - }, - { - "event": "boot_ok", - "vm_seq": 63, - "boot_time_s": 3.09, - "density_at_boot": 63, - "timestamp": 1773033216.403268, - "vms_running": 63, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 5.798877716064453, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 63, - "firecracker_rss_mb": 2964.92578125, - "fc_socket_count": 63, - "sqlite_db_kb": 112.0 - }, - { - "event": "boot_ok", - "vm_seq": 64, - "boot_time_s": 2.064, - "density_at_boot": 64, - "timestamp": 1773033218.6201143, - "vms_running": 64, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 5.846565246582031, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 64, - "firecracker_rss_mb": 3012.11328125, - "fc_socket_count": 64, - "sqlite_db_kb": 112.0 - }, - { - "event": "boot_ok", - "vm_seq": 65, - "boot_time_s": 2.039, - "density_at_boot": 65, - "timestamp": 1773033220.8116317, - "vms_running": 65, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.889556884765625, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 65, - "firecracker_rss_mb": 3058.78515625, - "fc_socket_count": 65, - "sqlite_db_kb": 112.0 - }, - { - "event": "boot_ok", - "vm_seq": 66, - "boot_time_s": 3.036, - "density_at_boot": 66, - "timestamp": 1773033224.000127, - "vms_running": 66, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 5.9334716796875, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 66, - "firecracker_rss_mb": 3105.72265625, - "fc_socket_count": 66, - "sqlite_db_kb": 116.0 - }, - { - "event": "boot_ok", - "vm_seq": 67, - "boot_time_s": 2.274, - "density_at_boot": 67, - "timestamp": 1773033226.4246364, - "vms_running": 67, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 5.988681793212891, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 67, - "firecracker_rss_mb": 3152.6484375, - "fc_socket_count": 67, - "sqlite_db_kb": 116.0 - }, - { - "event": "boot_ok", - "vm_seq": 68, - "boot_time_s": 3.103, - "density_at_boot": 68, - "timestamp": 1773033229.6829405, - "vms_running": 68, - "host_cpu_pct": 0.5, - "host_mem_used_gb": 6.028797149658203, - "host_disk_used_gb": 2.0466995239257812, - "tap_count": 68, - "firecracker_rss_mb": 3199.83203125, - "fc_socket_count": 68, - "sqlite_db_kb": 116.0 - }, - { - "event": "boot_ok", - "vm_seq": 69, - "boot_time_s": 3.05, - "density_at_boot": 69, - "timestamp": 1773033232.883963, - "vms_running": 69, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 6.079540252685547, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 69, - "firecracker_rss_mb": 3247.015625, - "fc_socket_count": 69, - "sqlite_db_kb": 116.0 - }, - { - "event": "boot_ok", - "vm_seq": 70, - "boot_time_s": 3.047, - "density_at_boot": 70, - "timestamp": 1773033236.083304, - "vms_running": 70, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 6.1288909912109375, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 70, - "firecracker_rss_mb": 3293.94140625, - "fc_socket_count": 70, - "sqlite_db_kb": 116.0 - }, - { - "event": "boot_ok", - "vm_seq": 71, - "boot_time_s": 3.045, - "density_at_boot": 71, - "timestamp": 1773033239.2812428, - "vms_running": 71, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.164848327636719, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 71, - "firecracker_rss_mb": 3340.8671875, - "fc_socket_count": 71, - "sqlite_db_kb": 120.0 - }, - { - "event": "boot_ok", - "vm_seq": 72, - "boot_time_s": 3.007, - "density_at_boot": 72, - "timestamp": 1773033242.4412746, - "vms_running": 72, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.211551666259766, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 72, - "firecracker_rss_mb": 3388.05078125, - "fc_socket_count": 72, - "sqlite_db_kb": 120.0 - }, - { - "event": "boot_ok", - "vm_seq": 73, - "boot_time_s": 3.088, - "density_at_boot": 73, - "timestamp": 1773033245.683507, - "vms_running": 73, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.2582550048828125, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 73, - "firecracker_rss_mb": 3435.23828125, - "fc_socket_count": 73, - "sqlite_db_kb": 120.0 - }, - { - "event": "boot_ok", - "vm_seq": 74, - "boot_time_s": 2.142, - "density_at_boot": 74, - "timestamp": 1773033247.978695, - "vms_running": 74, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.303688049316406, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 74, - "firecracker_rss_mb": 3481.90625, - "fc_socket_count": 74, - "sqlite_db_kb": 120.0 - }, - { - "event": "boot_ok", - "vm_seq": 75, - "boot_time_s": 2.031, - "density_at_boot": 75, - "timestamp": 1773033250.163482, - "vms_running": 75, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.348236083984375, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 75, - "firecracker_rss_mb": 3528.8359375, - "fc_socket_count": 75, - "sqlite_db_kb": 128.0 - }, - { - "event": "boot_ok", - "vm_seq": 76, - "boot_time_s": 2.186, - "density_at_boot": 76, - "timestamp": 1773033252.5023098, - "vms_running": 76, - "host_cpu_pct": 0.5, - "host_mem_used_gb": 6.395847320556641, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 76, - "firecracker_rss_mb": 3576.01953125, - "fc_socket_count": 76, - "sqlite_db_kb": 132.0 - }, - { - "event": "boot_ok", - "vm_seq": 77, - "boot_time_s": 3.112, - "density_at_boot": 77, - "timestamp": 1773033255.7646894, - "vms_running": 77, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.447135925292969, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 77, - "firecracker_rss_mb": 3622.69140625, - "fc_socket_count": 77, - "sqlite_db_kb": 132.0 - }, - { - "event": "boot_ok", - "vm_seq": 78, - "boot_time_s": 2.997, - "density_at_boot": 78, - "timestamp": 1773033258.9184716, - "vms_running": 78, - "host_cpu_pct": 0.6, - "host_mem_used_gb": 6.4872283935546875, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 78, - "firecracker_rss_mb": 3670.39453125, - "fc_socket_count": 78, - "sqlite_db_kb": 132.0 - }, - { - "event": "boot_ok", - "vm_seq": 79, - "boot_time_s": 3.011, - "density_at_boot": 79, - "timestamp": 1773033262.0819917, - "vms_running": 79, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.534366607666016, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 79, - "firecracker_rss_mb": 3717.3203125, - "fc_socket_count": 79, - "sqlite_db_kb": 132.0 - }, - { - "event": "boot_ok", - "vm_seq": 80, - "boot_time_s": 3.082, - "density_at_boot": 80, - "timestamp": 1773033265.3196058, - "vms_running": 80, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 6.580863952636719, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 80, - "firecracker_rss_mb": 3763.73046875, - "fc_socket_count": 80, - "sqlite_db_kb": 132.0 - }, - { - "event": "boot_ok", - "vm_seq": 81, - "boot_time_s": 2.965, - "density_at_boot": 81, - "timestamp": 1773033268.439817, - "vms_running": 81, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.624134063720703, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 81, - "firecracker_rss_mb": 3810.14453125, - "fc_socket_count": 81, - "sqlite_db_kb": 136.0 - }, - { - "event": "boot_ok", - "vm_seq": 82, - "boot_time_s": 3.007, - "density_at_boot": 82, - "timestamp": 1773033271.6033342, - "vms_running": 82, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 6.6730499267578125, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 82, - "firecracker_rss_mb": 3856.5546875, - "fc_socket_count": 82, - "sqlite_db_kb": 136.0 - }, - { - "event": "boot_ok", - "vm_seq": 83, - "boot_time_s": 2.999, - "density_at_boot": 83, - "timestamp": 1773033274.7591214, - "vms_running": 83, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.721355438232422, - "host_disk_used_gb": 2.045482635498047, - "tap_count": 83, - "firecracker_rss_mb": 3902.96875, - "fc_socket_count": 83, - "sqlite_db_kb": 136.0 - }, - { - "event": "boot_ok", - "vm_seq": 84, - "boot_time_s": 3.009, - "density_at_boot": 84, - "timestamp": 1773033277.9239209, - "vms_running": 84, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.7634429931640625, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 84, - "firecracker_rss_mb": 3950.15234375, - "fc_socket_count": 84, - "sqlite_db_kb": 136.0 - }, - { - "event": "boot_ok", - "vm_seq": 85, - "boot_time_s": 3.122, - "density_at_boot": 85, - "timestamp": 1773033281.2036185, - "vms_running": 85, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 6.805477142333984, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 85, - "firecracker_rss_mb": 3996.56640625, - "fc_socket_count": 85, - "sqlite_db_kb": 136.0 - }, - { - "event": "boot_ok", - "vm_seq": 86, - "boot_time_s": 3.124, - "density_at_boot": 86, - "timestamp": 1773033284.4832091, - "vms_running": 86, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 6.858394622802734, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 86, - "firecracker_rss_mb": 4042.98046875, - "fc_socket_count": 86, - "sqlite_db_kb": 140.0 - }, - { - "event": "boot_ok", - "vm_seq": 87, - "boot_time_s": 2.996, - "density_at_boot": 87, - "timestamp": 1773033287.63918, - "vms_running": 87, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 6.907325744628906, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 87, - "firecracker_rss_mb": 4090.42578125, - "fc_socket_count": 87, - "sqlite_db_kb": 140.0 - }, - { - "event": "boot_ok", - "vm_seq": 88, - "boot_time_s": 3.25, - "density_at_boot": 88, - "timestamp": 1773033291.0429933, - "vms_running": 88, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 6.96649169921875, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 88, - "firecracker_rss_mb": 4136.8359375, - "fc_socket_count": 88, - "sqlite_db_kb": 140.0 - }, - { - "event": "boot_ok", - "vm_seq": 89, - "boot_time_s": 3.04, - "density_at_boot": 89, - "timestamp": 1773033294.2414389, - "vms_running": 89, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.016696929931641, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 89, - "firecracker_rss_mb": 4184.28125, - "fc_socket_count": 89, - "sqlite_db_kb": 140.0 - }, - { - "event": "boot_ok", - "vm_seq": 90, - "boot_time_s": 3.127, - "density_at_boot": 90, - "timestamp": 1773033297.5242565, - "vms_running": 90, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.061672210693359, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 90, - "firecracker_rss_mb": 4230.953125, - "fc_socket_count": 90, - "sqlite_db_kb": 140.0 - }, - { - "event": "boot_ok", - "vm_seq": 91, - "boot_time_s": 3.121, - "density_at_boot": 91, - "timestamp": 1773033300.8026967, - "vms_running": 91, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 7.102863311767578, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 91, - "firecracker_rss_mb": 4278.13671875, - "fc_socket_count": 91, - "sqlite_db_kb": 144.0 - }, - { - "event": "boot_ok", - "vm_seq": 92, - "boot_time_s": 3.125, - "density_at_boot": 92, - "timestamp": 1773033304.0850515, - "vms_running": 92, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.147693634033203, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 92, - "firecracker_rss_mb": 4325.83984375, - "fc_socket_count": 92, - "sqlite_db_kb": 144.0 - }, - { - "event": "boot_ok", - "vm_seq": 93, - "boot_time_s": 2.18, - "density_at_boot": 93, - "timestamp": 1773033306.4212089, - "vms_running": 93, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 7.193912506103516, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 93, - "firecracker_rss_mb": 4372.25, - "fc_socket_count": 93, - "sqlite_db_kb": 144.0 - }, - { - "event": "boot_ok", - "vm_seq": 94, - "boot_time_s": 3.104, - "density_at_boot": 94, - "timestamp": 1773033309.6850111, - "vms_running": 94, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.243099212646484, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 94, - "firecracker_rss_mb": 4418.40625, - "fc_socket_count": 94, - "sqlite_db_kb": 144.0 - }, - { - "event": "boot_ok", - "vm_seq": 95, - "boot_time_s": 2.189, - "density_at_boot": 95, - "timestamp": 1773033312.0331566, - "vms_running": 95, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.286735534667969, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 95, - "firecracker_rss_mb": 4465.3359375, - "fc_socket_count": 95, - "sqlite_db_kb": 144.0 - }, - { - "event": "boot_ok", - "vm_seq": 96, - "boot_time_s": 3.088, - "density_at_boot": 96, - "timestamp": 1773033315.280903, - "vms_running": 96, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.325340270996094, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 96, - "firecracker_rss_mb": 4512.265625, - "fc_socket_count": 96, - "sqlite_db_kb": 148.0 - }, - { - "event": "boot_ok", - "vm_seq": 97, - "boot_time_s": 3.044, - "density_at_boot": 97, - "timestamp": 1773033318.4851127, - "vms_running": 97, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 7.373432159423828, - "host_disk_used_gb": 2.046703338623047, - "tap_count": 97, - "firecracker_rss_mb": 4559.19921875, - "fc_socket_count": 97, - "sqlite_db_kb": 148.0 - }, - { - "event": "boot_ok", - "vm_seq": 98, - "boot_time_s": 3.04, - "density_at_boot": 98, - "timestamp": 1773033321.6831727, - "vms_running": 98, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 7.423236846923828, - "host_disk_used_gb": 2.0467262268066406, - "tap_count": 98, - "firecracker_rss_mb": 4606.38671875, - "fc_socket_count": 98, - "sqlite_db_kb": 148.0 - }, - { - "event": "boot_ok", - "vm_seq": 99, - "boot_time_s": 3.124, - "density_at_boot": 99, - "timestamp": 1773033324.964652, - "vms_running": 99, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.467609405517578, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 99, - "firecracker_rss_mb": 4653.05859375, - "fc_socket_count": 99, - "sqlite_db_kb": 148.0 - }, - { - "event": "boot_ok", - "vm_seq": 100, - "boot_time_s": 3.122, - "density_at_boot": 100, - "timestamp": 1773033328.2430675, - "vms_running": 100, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 7.511039733886719, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 100, - "firecracker_rss_mb": 4699.46875, - "fc_socket_count": 100, - "sqlite_db_kb": 148.0 - }, - { - "event": "boot_ok", - "vm_seq": 101, - "boot_time_s": 3.127, - "density_at_boot": 101, - "timestamp": 1773033331.522668, - "vms_running": 101, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 7.559967041015625, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 101, - "firecracker_rss_mb": 4746.3984375, - "fc_socket_count": 101, - "sqlite_db_kb": 152.0 - }, - { - "event": "boot_ok", - "vm_seq": 102, - "boot_time_s": 2.18, - "density_at_boot": 102, - "timestamp": 1773033333.8610601, - "vms_running": 102, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 7.608421325683594, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 102, - "firecracker_rss_mb": 4793.0703125, - "fc_socket_count": 102, - "sqlite_db_kb": 152.0 - }, - { - "event": "boot_ok", - "vm_seq": 103, - "boot_time_s": 3.025, - "density_at_boot": 103, - "timestamp": 1773033337.0418603, - "vms_running": 103, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.656368255615234, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 103, - "firecracker_rss_mb": 4840.76953125, - "fc_socket_count": 103, - "sqlite_db_kb": 152.0 - }, - { - "event": "boot_ok", - "vm_seq": 104, - "boot_time_s": 2.184, - "density_at_boot": 104, - "timestamp": 1773033339.383744, - "vms_running": 104, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 7.709503173828125, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 104, - "firecracker_rss_mb": 4887.95703125, - "fc_socket_count": 104, - "sqlite_db_kb": 152.0 - }, - { - "event": "boot_ok", - "vm_seq": 105, - "boot_time_s": 3.184, - "density_at_boot": 105, - "timestamp": 1773033342.721289, - "vms_running": 105, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 7.748188018798828, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 105, - "firecracker_rss_mb": 4934.625, - "fc_socket_count": 105, - "sqlite_db_kb": 152.0 - }, - { - "event": "boot_ok", - "vm_seq": 106, - "boot_time_s": 3.08, - "density_at_boot": 106, - "timestamp": 1773033345.959677, - "vms_running": 106, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 7.791416168212891, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 106, - "firecracker_rss_mb": 4982.06640625, - "fc_socket_count": 106, - "sqlite_db_kb": 156.0 - }, - { - "event": "boot_ok", - "vm_seq": 107, - "boot_time_s": 2.106, - "density_at_boot": 107, - "timestamp": 1773033348.2202184, - "vms_running": 107, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 7.840679168701172, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 107, - "firecracker_rss_mb": 5028.4765625, - "fc_socket_count": 107, - "sqlite_db_kb": 156.0 - }, - { - "event": "boot_ok", - "vm_seq": 108, - "boot_time_s": 3.064, - "density_at_boot": 108, - "timestamp": 1773033351.4419806, - "vms_running": 108, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 7.8821258544921875, - "host_disk_used_gb": 2.0467071533203125, - "tap_count": 108, - "firecracker_rss_mb": 5075.40234375, - "fc_socket_count": 108, - "sqlite_db_kb": 156.0 - }, - { - "event": "boot_ok", - "vm_seq": 109, - "boot_time_s": 3.285, - "density_at_boot": 109, - "timestamp": 1773033354.881558, - "vms_running": 109, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 7.931728363037109, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 109, - "firecracker_rss_mb": 5122.328125, - "fc_socket_count": 109, - "sqlite_db_kb": 156.0 - }, - { - "event": "boot_ok", - "vm_seq": 110, - "boot_time_s": 2.181, - "density_at_boot": 110, - "timestamp": 1773033357.2215796, - "vms_running": 110, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 7.985015869140625, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 110, - "firecracker_rss_mb": 5169.25, - "fc_socket_count": 110, - "sqlite_db_kb": 156.0 - }, - { - "event": "boot_ok", - "vm_seq": 111, - "boot_time_s": 3.026, - "density_at_boot": 111, - "timestamp": 1773033360.4034083, - "vms_running": 111, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.026233673095703, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 111, - "firecracker_rss_mb": 5215.921875, - "fc_socket_count": 111, - "sqlite_db_kb": 160.0 - }, - { - "event": "boot_ok", - "vm_seq": 112, - "boot_time_s": 3.039, - "density_at_boot": 112, - "timestamp": 1773033363.60248, - "vms_running": 112, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.06964111328125, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 112, - "firecracker_rss_mb": 5262.58984375, - "fc_socket_count": 112, - "sqlite_db_kb": 160.0 - }, - { - "event": "boot_ok", - "vm_seq": 113, - "boot_time_s": 3.121, - "density_at_boot": 113, - "timestamp": 1773033366.8814447, - "vms_running": 113, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.123348236083984, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 113, - "firecracker_rss_mb": 5309.26171875, - "fc_socket_count": 113, - "sqlite_db_kb": 160.0 - }, - { - "event": "boot_ok", - "vm_seq": 114, - "boot_time_s": 3.135, - "density_at_boot": 114, - "timestamp": 1773033370.1746638, - "vms_running": 114, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.168418884277344, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 114, - "firecracker_rss_mb": 5356.19140625, - "fc_socket_count": 114, - "sqlite_db_kb": 160.0 - }, - { - "event": "boot_ok", - "vm_seq": 115, - "boot_time_s": 3.112, - "density_at_boot": 115, - "timestamp": 1773033373.4441922, - "vms_running": 115, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.210132598876953, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 115, - "firecracker_rss_mb": 5403.37890625, - "fc_socket_count": 115, - "sqlite_db_kb": 160.0 - }, - { - "event": "boot_ok", - "vm_seq": 116, - "boot_time_s": 3.121, - "density_at_boot": 116, - "timestamp": 1773033376.7231078, - "vms_running": 116, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.251083374023438, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 116, - "firecracker_rss_mb": 5450.046875, - "fc_socket_count": 116, - "sqlite_db_kb": 164.0 - }, - { - "event": "boot_ok", - "vm_seq": 117, - "boot_time_s": 3.122, - "density_at_boot": 117, - "timestamp": 1773033380.0035434, - "vms_running": 117, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 8.304367065429688, - "host_disk_used_gb": 2.0467300415039062, - "tap_count": 117, - "firecracker_rss_mb": 5496.9765625, - "fc_socket_count": 117, - "sqlite_db_kb": 164.0 - }, - { - "event": "boot_ok", - "vm_seq": 118, - "boot_time_s": 3.202, - "density_at_boot": 118, - "timestamp": 1773033383.3633437, - "vms_running": 118, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.354461669921875, - "host_disk_used_gb": 2.046710968017578, - "tap_count": 118, - "firecracker_rss_mb": 5543.8984375, - "fc_socket_count": 118, - "sqlite_db_kb": 164.0 - }, - { - "event": "boot_ok", - "vm_seq": 119, - "boot_time_s": 3.117, - "density_at_boot": 119, - "timestamp": 1773033386.6418316, - "vms_running": 119, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 8.395759582519531, - "host_disk_used_gb": 2.046710968017578, - "tap_count": 119, - "firecracker_rss_mb": 5590.56640625, - "fc_socket_count": 119, - "sqlite_db_kb": 164.0 - }, - { - "event": "boot_ok", - "vm_seq": 120, - "boot_time_s": 3.123, - "density_at_boot": 120, - "timestamp": 1773033389.9224994, - "vms_running": 120, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.447036743164062, - "host_disk_used_gb": 2.046710968017578, - "tap_count": 120, - "firecracker_rss_mb": 5636.97265625, - "fc_socket_count": 120, - "sqlite_db_kb": 168.0 - }, - { - "event": "boot_ok", - "vm_seq": 121, - "boot_time_s": 3.076, - "density_at_boot": 121, - "timestamp": 1773033393.1599932, - "vms_running": 121, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.49530029296875, - "host_disk_used_gb": 2.046710968017578, - "tap_count": 121, - "firecracker_rss_mb": 5684.15234375, - "fc_socket_count": 121, - "sqlite_db_kb": 172.0 - }, - { - "event": "boot_ok", - "vm_seq": 122, - "boot_time_s": 3.082, - "density_at_boot": 122, - "timestamp": 1773033396.4016879, - "vms_running": 122, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.541004180908203, - "host_disk_used_gb": 2.046710968017578, - "tap_count": 122, - "firecracker_rss_mb": 5731.33984375, - "fc_socket_count": 122, - "sqlite_db_kb": 172.0 - }, - { - "event": "boot_ok", - "vm_seq": 123, - "boot_time_s": 3.04, - "density_at_boot": 123, - "timestamp": 1773033399.601394, - "vms_running": 123, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.587997436523438, - "host_disk_used_gb": 2.048664093017578, - "tap_count": 123, - "firecracker_rss_mb": 5778.00390625, - "fc_socket_count": 123, - "sqlite_db_kb": 172.0 - }, - { - "event": "boot_ok", - "vm_seq": 124, - "boot_time_s": 3.201, - "density_at_boot": 124, - "timestamp": 1773033402.96306, - "vms_running": 124, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.630805969238281, - "host_disk_used_gb": 2.048664093017578, - "tap_count": 124, - "firecracker_rss_mb": 5824.671875, - "fc_socket_count": 124, - "sqlite_db_kb": 172.0 - }, - { - "event": "boot_ok", - "vm_seq": 125, - "boot_time_s": 3.117, - "density_at_boot": 125, - "timestamp": 1773033406.2411644, - "vms_running": 125, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 8.680839538574219, - "host_disk_used_gb": 2.048664093017578, - "tap_count": 125, - "firecracker_rss_mb": 5871.0859375, - "fc_socket_count": 125, - "sqlite_db_kb": 172.0 - }, - { - "event": "boot_ok", - "vm_seq": 126, - "boot_time_s": 3.08, - "density_at_boot": 126, - "timestamp": 1773033409.4800408, - "vms_running": 126, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 8.728694915771484, - "host_disk_used_gb": 2.048664093017578, - "tap_count": 126, - "firecracker_rss_mb": 5918.53125, - "fc_socket_count": 126, - "sqlite_db_kb": 176.0 - }, - { - "event": "boot_ok", - "vm_seq": 127, - "boot_time_s": 3.088, - "density_at_boot": 127, - "timestamp": 1773033412.7238917, - "vms_running": 127, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.772705078125, - "host_disk_used_gb": 2.048664093017578, - "tap_count": 127, - "firecracker_rss_mb": 5965.71484375, - "fc_socket_count": 127, - "sqlite_db_kb": 176.0 - }, - { - "event": "boot_ok", - "vm_seq": 128, - "boot_time_s": 3.117, - "density_at_boot": 128, - "timestamp": 1773033416.000301, - "vms_running": 128, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.832965850830078, - "host_disk_used_gb": 2.0486679077148438, - "tap_count": 128, - "firecracker_rss_mb": 6012.640625, - "fc_socket_count": 128, - "sqlite_db_kb": 176.0 - }, - { - "event": "boot_ok", - "vm_seq": 129, - "boot_time_s": 3.119, - "density_at_boot": 129, - "timestamp": 1773033419.281909, - "vms_running": 129, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 8.882610321044922, - "host_disk_used_gb": 2.0486679077148438, - "tap_count": 129, - "firecracker_rss_mb": 6059.56640625, - "fc_socket_count": 129, - "sqlite_db_kb": 176.0 - }, - { - "event": "boot_ok", - "vm_seq": 130, - "boot_time_s": 3.117, - "density_at_boot": 130, - "timestamp": 1773033422.562466, - "vms_running": 130, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 8.926074981689453, - "host_disk_used_gb": 2.0486679077148438, - "tap_count": 130, - "firecracker_rss_mb": 6107.0078125, - "fc_socket_count": 130, - "sqlite_db_kb": 176.0 - }, - { - "event": "boot_ok", - "vm_seq": 131, - "boot_time_s": 3.121, - "density_at_boot": 131, - "timestamp": 1773033425.844859, - "vms_running": 131, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 8.970325469970703, - "host_disk_used_gb": 2.0486679077148438, - "tap_count": 131, - "firecracker_rss_mb": 6153.421875, - "fc_socket_count": 131, - "sqlite_db_kb": 180.0 - }, - { - "event": "boot_ok", - "vm_seq": 132, - "boot_time_s": 2.254, - "density_at_boot": 132, - "timestamp": 1773033428.2608886, - "vms_running": 132, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.01382064819336, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 132, - "firecracker_rss_mb": 6200.08984375, - "fc_socket_count": 132, - "sqlite_db_kb": 180.0 - }, - { - "event": "boot_ok", - "vm_seq": 133, - "boot_time_s": 3.099, - "density_at_boot": 133, - "timestamp": 1773033431.521233, - "vms_running": 133, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 9.0545654296875, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 133, - "firecracker_rss_mb": 6246.50390625, - "fc_socket_count": 133, - "sqlite_db_kb": 180.0 - }, - { - "event": "boot_ok", - "vm_seq": 134, - "boot_time_s": 3.121, - "density_at_boot": 134, - "timestamp": 1773033434.803238, - "vms_running": 134, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 9.105091094970703, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 134, - "firecracker_rss_mb": 6293.42578125, - "fc_socket_count": 134, - "sqlite_db_kb": 180.0 - }, - { - "event": "boot_ok", - "vm_seq": 135, - "boot_time_s": 3.118, - "density_at_boot": 135, - "timestamp": 1773033438.0817564, - "vms_running": 135, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.156326293945312, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 135, - "firecracker_rss_mb": 6340.34765625, - "fc_socket_count": 135, - "sqlite_db_kb": 180.0 - }, - { - "event": "boot_ok", - "vm_seq": 136, - "boot_time_s": 3.123, - "density_at_boot": 136, - "timestamp": 1773033441.3631392, - "vms_running": 136, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.193977355957031, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 136, - "firecracker_rss_mb": 6387.27734375, - "fc_socket_count": 136, - "sqlite_db_kb": 184.0 - }, - { - "event": "boot_ok", - "vm_seq": 137, - "boot_time_s": 3.119, - "density_at_boot": 137, - "timestamp": 1773033444.6434557, - "vms_running": 137, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.247077941894531, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 137, - "firecracker_rss_mb": 6433.9453125, - "fc_socket_count": 137, - "sqlite_db_kb": 184.0 - }, - { - "event": "boot_ok", - "vm_seq": 138, - "boot_time_s": 3.075, - "density_at_boot": 138, - "timestamp": 1773033447.87982, - "vms_running": 138, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 9.296798706054688, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 138, - "firecracker_rss_mb": 6480.35546875, - "fc_socket_count": 138, - "sqlite_db_kb": 184.0 - }, - { - "event": "boot_ok", - "vm_seq": 139, - "boot_time_s": 2.222, - "density_at_boot": 139, - "timestamp": 1773033450.2640986, - "vms_running": 139, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.344768524169922, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 139, - "firecracker_rss_mb": 6527.54296875, - "fc_socket_count": 139, - "sqlite_db_kb": 184.0 - }, - { - "event": "boot_ok", - "vm_seq": 140, - "boot_time_s": 3.1, - "density_at_boot": 140, - "timestamp": 1773033453.524573, - "vms_running": 140, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.38943862915039, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 140, - "firecracker_rss_mb": 6574.21484375, - "fc_socket_count": 140, - "sqlite_db_kb": 184.0 - }, - { - "event": "boot_ok", - "vm_seq": 141, - "boot_time_s": 3.117, - "density_at_boot": 141, - "timestamp": 1773033456.803698, - "vms_running": 141, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 9.433296203613281, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 141, - "firecracker_rss_mb": 6622.17578125, - "fc_socket_count": 141, - "sqlite_db_kb": 188.0 - }, - { - "event": "boot_ok", - "vm_seq": 142, - "boot_time_s": 3.115, - "density_at_boot": 142, - "timestamp": 1773033460.0809586, - "vms_running": 142, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.485233306884766, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 142, - "firecracker_rss_mb": 6669.10546875, - "fc_socket_count": 142, - "sqlite_db_kb": 188.0 - }, - { - "event": "boot_ok", - "vm_seq": 143, - "boot_time_s": 2.257, - "density_at_boot": 143, - "timestamp": 1773033462.5032816, - "vms_running": 143, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.534984588623047, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 143, - "firecracker_rss_mb": 6715.7734375, - "fc_socket_count": 143, - "sqlite_db_kb": 188.0 - }, - { - "event": "boot_ok", - "vm_seq": 144, - "boot_time_s": 3.092, - "density_at_boot": 144, - "timestamp": 1773033465.7614236, - "vms_running": 144, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 9.581172943115234, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 144, - "firecracker_rss_mb": 6762.18359375, - "fc_socket_count": 144, - "sqlite_db_kb": 188.0 - }, - { - "event": "boot_ok", - "vm_seq": 145, - "boot_time_s": 2.259, - "density_at_boot": 145, - "timestamp": 1773033468.1824205, - "vms_running": 145, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.623035430908203, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 145, - "firecracker_rss_mb": 6808.59375, - "fc_socket_count": 145, - "sqlite_db_kb": 188.0 - }, - { - "event": "boot_ok", - "vm_seq": 146, - "boot_time_s": 2.237, - "density_at_boot": 146, - "timestamp": 1773033470.5823827, - "vms_running": 146, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.670127868652344, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 146, - "firecracker_rss_mb": 6855.7734375, - "fc_socket_count": 146, - "sqlite_db_kb": 192.0 - }, - { - "event": "boot_ok", - "vm_seq": 147, - "boot_time_s": 3.099, - "density_at_boot": 147, - "timestamp": 1773033473.8449368, - "vms_running": 147, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.725379943847656, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 147, - "firecracker_rss_mb": 6903.4765625, - "fc_socket_count": 147, - "sqlite_db_kb": 192.0 - }, - { - "event": "boot_ok", - "vm_seq": 148, - "boot_time_s": 3.113, - "density_at_boot": 148, - "timestamp": 1773033477.121257, - "vms_running": 148, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.766246795654297, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 148, - "firecracker_rss_mb": 6950.1484375, - "fc_socket_count": 148, - "sqlite_db_kb": 196.0 - }, - { - "event": "boot_ok", - "vm_seq": 149, - "boot_time_s": 2.34, - "density_at_boot": 149, - "timestamp": 1773033479.6245906, - "vms_running": 149, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.817317962646484, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 149, - "firecracker_rss_mb": 6996.8203125, - "fc_socket_count": 149, - "sqlite_db_kb": 196.0 - }, - { - "event": "boot_ok", - "vm_seq": 150, - "boot_time_s": 3.093, - "density_at_boot": 150, - "timestamp": 1773033482.8818614, - "vms_running": 150, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 9.861000061035156, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 150, - "firecracker_rss_mb": 7043.4921875, - "fc_socket_count": 150, - "sqlite_db_kb": 196.0 - }, - { - "event": "boot_ok", - "vm_seq": 151, - "boot_time_s": 3.116, - "density_at_boot": 151, - "timestamp": 1773033486.1640375, - "vms_running": 151, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.906044006347656, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 151, - "firecracker_rss_mb": 7090.15625, - "fc_socket_count": 151, - "sqlite_db_kb": 200.0 - }, - { - "event": "boot_ok", - "vm_seq": 152, - "boot_time_s": 3.193, - "density_at_boot": 152, - "timestamp": 1773033489.521806, - "vms_running": 152, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 9.950984954833984, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 152, - "firecracker_rss_mb": 7136.828125, - "fc_socket_count": 152, - "sqlite_db_kb": 200.0 - }, - { - "event": "boot_ok", - "vm_seq": 153, - "boot_time_s": 3.194, - "density_at_boot": 153, - "timestamp": 1773033492.8805733, - "vms_running": 153, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 9.998855590820312, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 153, - "firecracker_rss_mb": 7183.75390625, - "fc_socket_count": 153, - "sqlite_db_kb": 200.0 - }, - { - "event": "boot_ok", - "vm_seq": 154, - "boot_time_s": 2.252, - "density_at_boot": 154, - "timestamp": 1773033495.3022184, - "vms_running": 154, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.040069580078125, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 154, - "firecracker_rss_mb": 7230.42578125, - "fc_socket_count": 154, - "sqlite_db_kb": 200.0 - }, - { - "event": "boot_ok", - "vm_seq": 155, - "boot_time_s": 3.254, - "density_at_boot": 155, - "timestamp": 1773033498.7247493, - "vms_running": 155, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 10.091270446777344, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 155, - "firecracker_rss_mb": 7277.09375, - "fc_socket_count": 155, - "sqlite_db_kb": 200.0 - }, - { - "event": "boot_ok", - "vm_seq": 156, - "boot_time_s": 3.193, - "density_at_boot": 156, - "timestamp": 1773033502.0826788, - "vms_running": 156, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 10.131889343261719, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 156, - "firecracker_rss_mb": 7324.26953125, - "fc_socket_count": 156, - "sqlite_db_kb": 204.0 - }, - { - "event": "boot_ok", - "vm_seq": 157, - "boot_time_s": 3.119, - "density_at_boot": 157, - "timestamp": 1773033505.362828, - "vms_running": 157, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.181037902832031, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 157, - "firecracker_rss_mb": 7370.94140625, - "fc_socket_count": 157, - "sqlite_db_kb": 204.0 - }, - { - "event": "boot_ok", - "vm_seq": 158, - "boot_time_s": 3.112, - "density_at_boot": 158, - "timestamp": 1773033508.6444862, - "vms_running": 158, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.230438232421875, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 158, - "firecracker_rss_mb": 7417.87109375, - "fc_socket_count": 158, - "sqlite_db_kb": 204.0 - }, - { - "event": "boot_ok", - "vm_seq": 159, - "boot_time_s": 3.109, - "density_at_boot": 159, - "timestamp": 1773033511.9205093, - "vms_running": 159, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.284061431884766, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 159, - "firecracker_rss_mb": 7464.796875, - "fc_socket_count": 159, - "sqlite_db_kb": 204.0 - }, - { - "event": "boot_ok", - "vm_seq": 160, - "boot_time_s": 3.194, - "density_at_boot": 160, - "timestamp": 1773033515.2842944, - "vms_running": 160, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.324714660644531, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 160, - "firecracker_rss_mb": 7511.203125, - "fc_socket_count": 160, - "sqlite_db_kb": 204.0 - }, - { - "event": "boot_ok", - "vm_seq": 161, - "boot_time_s": 2.253, - "density_at_boot": 161, - "timestamp": 1773033517.7042155, - "vms_running": 161, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.376792907714844, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 161, - "firecracker_rss_mb": 7558.12890625, - "fc_socket_count": 161, - "sqlite_db_kb": 208.0 - }, - { - "event": "boot_ok", - "vm_seq": 162, - "boot_time_s": 3.094, - "density_at_boot": 162, - "timestamp": 1773033520.9644217, - "vms_running": 162, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.431446075439453, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 162, - "firecracker_rss_mb": 7605.0546875, - "fc_socket_count": 162, - "sqlite_db_kb": 208.0 - }, - { - "event": "boot_ok", - "vm_seq": 163, - "boot_time_s": 3.11, - "density_at_boot": 163, - "timestamp": 1773033524.243907, - "vms_running": 163, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.468460083007812, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 163, - "firecracker_rss_mb": 7651.98046875, - "fc_socket_count": 163, - "sqlite_db_kb": 208.0 - }, - { - "event": "boot_ok", - "vm_seq": 164, - "boot_time_s": 3.191, - "density_at_boot": 164, - "timestamp": 1773033527.6043, - "vms_running": 164, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.510318756103516, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 164, - "firecracker_rss_mb": 7698.90625, - "fc_socket_count": 164, - "sqlite_db_kb": 208.0 - }, - { - "event": "boot_ok", - "vm_seq": 165, - "boot_time_s": 3.108, - "density_at_boot": 165, - "timestamp": 1773033530.8813622, - "vms_running": 165, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.557815551757812, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 165, - "firecracker_rss_mb": 7745.8359375, - "fc_socket_count": 165, - "sqlite_db_kb": 208.0 - }, - { - "event": "boot_ok", - "vm_seq": 166, - "boot_time_s": 3.123, - "density_at_boot": 166, - "timestamp": 1773033534.1663275, - "vms_running": 166, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.608741760253906, - "host_disk_used_gb": 2.0564804077148438, - "tap_count": 166, - "firecracker_rss_mb": 7793.01953125, - "fc_socket_count": 166, - "sqlite_db_kb": 212.0 - }, - { - "event": "boot_ok", - "vm_seq": 167, - "boot_time_s": 3.189, - "density_at_boot": 167, - "timestamp": 1773033537.5240815, - "vms_running": 167, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.653961181640625, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 167, - "firecracker_rss_mb": 7839.94140625, - "fc_socket_count": 167, - "sqlite_db_kb": 212.0 - }, - { - "event": "boot_ok", - "vm_seq": 168, - "boot_time_s": 2.25, - "density_at_boot": 168, - "timestamp": 1773033539.9457948, - "vms_running": 168, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 10.698810577392578, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 168, - "firecracker_rss_mb": 7886.61328125, - "fc_socket_count": 168, - "sqlite_db_kb": 212.0 - }, - { - "event": "boot_ok", - "vm_seq": 169, - "boot_time_s": 3.168, - "density_at_boot": 169, - "timestamp": 1773033543.2839813, - "vms_running": 169, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 10.747535705566406, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 169, - "firecracker_rss_mb": 7933.5390625, - "fc_socket_count": 169, - "sqlite_db_kb": 212.0 - }, - { - "event": "boot_ok", - "vm_seq": 170, - "boot_time_s": 3.347, - "density_at_boot": 170, - "timestamp": 1773033546.8029087, - "vms_running": 170, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 10.788501739501953, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 170, - "firecracker_rss_mb": 7980.2109375, - "fc_socket_count": 170, - "sqlite_db_kb": 212.0 - }, - { - "event": "boot_ok", - "vm_seq": 171, - "boot_time_s": 3.111, - "density_at_boot": 171, - "timestamp": 1773033550.0837052, - "vms_running": 171, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 10.838539123535156, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 171, - "firecracker_rss_mb": 8026.625, - "fc_socket_count": 171, - "sqlite_db_kb": 216.0 - }, - { - "event": "boot_ok", - "vm_seq": 172, - "boot_time_s": 3.107, - "density_at_boot": 172, - "timestamp": 1773033553.3607836, - "vms_running": 172, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 10.891731262207031, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 172, - "firecracker_rss_mb": 8073.5546875, - "fc_socket_count": 172, - "sqlite_db_kb": 216.0 - }, - { - "event": "boot_ok", - "vm_seq": 173, - "boot_time_s": 3.191, - "density_at_boot": 173, - "timestamp": 1773033556.7229428, - "vms_running": 173, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 10.934406280517578, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 173, - "firecracker_rss_mb": 8119.96484375, - "fc_socket_count": 173, - "sqlite_db_kb": 216.0 - }, - { - "event": "boot_ok", - "vm_seq": 174, - "boot_time_s": 3.111, - "density_at_boot": 174, - "timestamp": 1773033560.0019217, - "vms_running": 174, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 10.979808807373047, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 174, - "firecracker_rss_mb": 8166.890625, - "fc_socket_count": 174, - "sqlite_db_kb": 216.0 - }, - { - "event": "boot_ok", - "vm_seq": 175, - "boot_time_s": 3.111, - "density_at_boot": 175, - "timestamp": 1773033563.2828329, - "vms_running": 175, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.024150848388672, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 175, - "firecracker_rss_mb": 8213.55859375, - "fc_socket_count": 175, - "sqlite_db_kb": 216.0 - }, - { - "event": "boot_ok", - "vm_seq": 176, - "boot_time_s": 3.068, - "density_at_boot": 176, - "timestamp": 1773033566.5202913, - "vms_running": 176, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 11.070877075195312, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 176, - "firecracker_rss_mb": 8259.96484375, - "fc_socket_count": 176, - "sqlite_db_kb": 220.0 - }, - { - "event": "boot_ok", - "vm_seq": 177, - "boot_time_s": 3.15, - "density_at_boot": 177, - "timestamp": 1773033569.841767, - "vms_running": 177, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.11007308959961, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 177, - "firecracker_rss_mb": 8306.89453125, - "fc_socket_count": 177, - "sqlite_db_kb": 224.0 - }, - { - "event": "boot_ok", - "vm_seq": 178, - "boot_time_s": 3.109, - "density_at_boot": 178, - "timestamp": 1773033573.1206295, - "vms_running": 178, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.160285949707031, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 178, - "firecracker_rss_mb": 8353.82421875, - "fc_socket_count": 178, - "sqlite_db_kb": 224.0 - }, - { - "event": "boot_ok", - "vm_seq": 179, - "boot_time_s": 2.253, - "density_at_boot": 179, - "timestamp": 1773033575.5447557, - "vms_running": 179, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.212104797363281, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 179, - "firecracker_rss_mb": 8400.75, - "fc_socket_count": 179, - "sqlite_db_kb": 224.0 - }, - { - "event": "boot_ok", - "vm_seq": 180, - "boot_time_s": 3.165, - "density_at_boot": 180, - "timestamp": 1773033578.8825028, - "vms_running": 180, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 11.261924743652344, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 180, - "firecracker_rss_mb": 8447.9375, - "fc_socket_count": 180, - "sqlite_db_kb": 224.0 - }, - { - "event": "boot_ok", - "vm_seq": 181, - "boot_time_s": 3.193, - "density_at_boot": 181, - "timestamp": 1773033582.2439106, - "vms_running": 181, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 11.309494018554688, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 181, - "firecracker_rss_mb": 8494.86328125, - "fc_socket_count": 181, - "sqlite_db_kb": 228.0 - }, - { - "event": "boot_ok", - "vm_seq": 182, - "boot_time_s": 3.188, - "density_at_boot": 182, - "timestamp": 1773033585.6021996, - "vms_running": 182, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.352672576904297, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 182, - "firecracker_rss_mb": 8541.2734375, - "fc_socket_count": 182, - "sqlite_db_kb": 228.0 - }, - { - "event": "boot_ok", - "vm_seq": 183, - "boot_time_s": 3.149, - "density_at_boot": 183, - "timestamp": 1773033588.9205325, - "vms_running": 183, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.397899627685547, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 183, - "firecracker_rss_mb": 8588.45703125, - "fc_socket_count": 183, - "sqlite_db_kb": 228.0 - }, - { - "event": "boot_ok", - "vm_seq": 184, - "boot_time_s": 3.157, - "density_at_boot": 184, - "timestamp": 1773033592.2446215, - "vms_running": 184, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 11.445987701416016, - "host_disk_used_gb": 2.056476593017578, - "tap_count": 184, - "firecracker_rss_mb": 8635.12890625, - "fc_socket_count": 184, - "sqlite_db_kb": 228.0 - }, - { - "event": "boot_ok", - "vm_seq": 185, - "boot_time_s": 3.19, - "density_at_boot": 185, - "timestamp": 1773033595.6052225, - "vms_running": 185, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.482105255126953, - "host_disk_used_gb": 2.064289093017578, - "tap_count": 185, - "firecracker_rss_mb": 8682.3125, - "fc_socket_count": 185, - "sqlite_db_kb": 228.0 - }, - { - "event": "boot_ok", - "vm_seq": 186, - "boot_time_s": 3.188, - "density_at_boot": 186, - "timestamp": 1773033598.9635153, - "vms_running": 186, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.541004180908203, - "host_disk_used_gb": 2.068195343017578, - "tap_count": 186, - "firecracker_rss_mb": 8729.23828125, - "fc_socket_count": 186, - "sqlite_db_kb": 232.0 - }, - { - "event": "boot_ok", - "vm_seq": 187, - "boot_time_s": 2.226, - "density_at_boot": 187, - "timestamp": 1773033601.3632512, - "vms_running": 187, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 11.587959289550781, - "host_disk_used_gb": 2.0681991577148438, - "tap_count": 187, - "firecracker_rss_mb": 8775.90625, - "fc_socket_count": 187, - "sqlite_db_kb": 232.0 - }, - { - "event": "boot_ok", - "vm_seq": 188, - "boot_time_s": 3.346, - "density_at_boot": 188, - "timestamp": 1773033604.8829737, - "vms_running": 188, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.639976501464844, - "host_disk_used_gb": 2.068256378173828, - "tap_count": 188, - "firecracker_rss_mb": 8822.578125, - "fc_socket_count": 188, - "sqlite_db_kb": 232.0 - }, - { - "event": "boot_ok", - "vm_seq": 189, - "boot_time_s": 3.187, - "density_at_boot": 189, - "timestamp": 1773033608.2422018, - "vms_running": 189, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.687469482421875, - "host_disk_used_gb": 2.0682373046875, - "tap_count": 189, - "firecracker_rss_mb": 8868.98828125, - "fc_socket_count": 189, - "sqlite_db_kb": 232.0 - }, - { - "event": "boot_ok", - "vm_seq": 190, - "boot_time_s": 3.271, - "density_at_boot": 190, - "timestamp": 1773033611.6846218, - "vms_running": 190, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.74105453491211, - "host_disk_used_gb": 2.0682373046875, - "tap_count": 190, - "firecracker_rss_mb": 8916.17578125, - "fc_socket_count": 190, - "sqlite_db_kb": 232.0 - }, - { - "event": "boot_ok", - "vm_seq": 191, - "boot_time_s": 2.209, - "density_at_boot": 191, - "timestamp": 1773033614.0609727, - "vms_running": 191, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 11.793479919433594, - "host_disk_used_gb": 2.0682601928710938, - "tap_count": 191, - "firecracker_rss_mb": 8963.1015625, - "fc_socket_count": 191, - "sqlite_db_kb": 236.0 - }, - { - "event": "boot_ok", - "vm_seq": 192, - "boot_time_s": 2.264, - "density_at_boot": 192, - "timestamp": 1773033616.501715, - "vms_running": 192, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 11.839092254638672, - "host_disk_used_gb": 2.0682601928710938, - "tap_count": 192, - "firecracker_rss_mb": 9009.2578125, - "fc_socket_count": 192, - "sqlite_db_kb": 236.0 - }, - { - "event": "boot_ok", - "vm_seq": 193, - "boot_time_s": 3.328, - "density_at_boot": 193, - "timestamp": 1773033620.0044794, - "vms_running": 193, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.886859893798828, - "host_disk_used_gb": 2.0682601928710938, - "tap_count": 193, - "firecracker_rss_mb": 9055.671875, - "fc_socket_count": 193, - "sqlite_db_kb": 236.0 - }, - { - "event": "boot_ok", - "vm_seq": 194, - "boot_time_s": 3.187, - "density_at_boot": 194, - "timestamp": 1773033623.3625393, - "vms_running": 194, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 11.928947448730469, - "host_disk_used_gb": 2.0682601928710938, - "tap_count": 194, - "firecracker_rss_mb": 9102.6015625, - "fc_socket_count": 194, - "sqlite_db_kb": 236.0 - }, - { - "event": "boot_ok", - "vm_seq": 195, - "boot_time_s": 3.194, - "density_at_boot": 195, - "timestamp": 1773033626.7250767, - "vms_running": 195, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 11.971641540527344, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 195, - "firecracker_rss_mb": 9149.26953125, - "fc_socket_count": 195, - "sqlite_db_kb": 236.0 - }, - { - "event": "boot_ok", - "vm_seq": 196, - "boot_time_s": 3.185, - "density_at_boot": 196, - "timestamp": 1773033630.0824122, - "vms_running": 196, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.018150329589844, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 196, - "firecracker_rss_mb": 9196.453125, - "fc_socket_count": 196, - "sqlite_db_kb": 240.0 - }, - { - "event": "boot_ok", - "vm_seq": 197, - "boot_time_s": 3.188, - "density_at_boot": 197, - "timestamp": 1773033633.4426615, - "vms_running": 197, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 12.065910339355469, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 197, - "firecracker_rss_mb": 9243.3828125, - "fc_socket_count": 197, - "sqlite_db_kb": 240.0 - }, - { - "event": "boot_ok", - "vm_seq": 198, - "boot_time_s": 3.187, - "density_at_boot": 198, - "timestamp": 1773033636.802098, - "vms_running": 198, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.115619659423828, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 198, - "firecracker_rss_mb": 9290.30859375, - "fc_socket_count": 198, - "sqlite_db_kb": 240.0 - }, - { - "event": "boot_ok", - "vm_seq": 199, - "boot_time_s": 3.141, - "density_at_boot": 199, - "timestamp": 1773033640.119371, - "vms_running": 199, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 12.157161712646484, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 199, - "firecracker_rss_mb": 9337.23828125, - "fc_socket_count": 199, - "sqlite_db_kb": 240.0 - }, - { - "event": "boot_ok", - "vm_seq": 200, - "boot_time_s": 3.15, - "density_at_boot": 200, - "timestamp": 1773033643.4410403, - "vms_running": 200, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.199546813964844, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 200, - "firecracker_rss_mb": 9383.65234375, - "fc_socket_count": 200, - "sqlite_db_kb": 240.0 - }, - { - "event": "boot_ok", - "vm_seq": 201, - "boot_time_s": 3.187, - "density_at_boot": 201, - "timestamp": 1773033646.8031938, - "vms_running": 201, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.243377685546875, - "host_disk_used_gb": 2.0682830810546875, - "tap_count": 201, - "firecracker_rss_mb": 9430.83984375, - "fc_socket_count": 201, - "sqlite_db_kb": 244.0 - }, - { - "event": "boot_ok", - "vm_seq": 202, - "boot_time_s": 2.21, - "density_at_boot": 202, - "timestamp": 1773033649.1886933, - "vms_running": 202, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.294654846191406, - "host_disk_used_gb": 2.0682640075683594, - "tap_count": 202, - "firecracker_rss_mb": 9477.51171875, - "fc_socket_count": 202, - "sqlite_db_kb": 244.0 - }, - { - "event": "boot_ok", - "vm_seq": 203, - "boot_time_s": 3.117, - "density_at_boot": 203, - "timestamp": 1773033652.4823601, - "vms_running": 203, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 12.346118927001953, - "host_disk_used_gb": 2.0682640075683594, - "tap_count": 203, - "firecracker_rss_mb": 9524.9609375, - "fc_socket_count": 203, - "sqlite_db_kb": 244.0 - }, - { - "event": "boot_ok", - "vm_seq": 204, - "boot_time_s": 3.184, - "density_at_boot": 204, - "timestamp": 1773033655.8429387, - "vms_running": 204, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.397769927978516, - "host_disk_used_gb": 2.0682640075683594, - "tap_count": 204, - "firecracker_rss_mb": 9571.6328125, - "fc_socket_count": 204, - "sqlite_db_kb": 244.0 - }, - { - "event": "boot_ok", - "vm_seq": 205, - "boot_time_s": 3.185, - "density_at_boot": 205, - "timestamp": 1773033659.2011416, - "vms_running": 205, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.447380065917969, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 205, - "firecracker_rss_mb": 9618.5546875, - "fc_socket_count": 205, - "sqlite_db_kb": 244.0 - }, - { - "event": "boot_ok", - "vm_seq": 206, - "boot_time_s": 3.141, - "density_at_boot": 206, - "timestamp": 1773033662.5197165, - "vms_running": 206, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 12.492847442626953, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 206, - "firecracker_rss_mb": 9665.484375, - "fc_socket_count": 206, - "sqlite_db_kb": 248.0 - }, - { - "event": "boot_ok", - "vm_seq": 207, - "boot_time_s": 3.183, - "density_at_boot": 207, - "timestamp": 1773033665.8796723, - "vms_running": 207, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 12.531898498535156, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 207, - "firecracker_rss_mb": 9712.1484375, - "fc_socket_count": 207, - "sqlite_db_kb": 248.0 - }, - { - "event": "boot_ok", - "vm_seq": 208, - "boot_time_s": 3.224, - "density_at_boot": 208, - "timestamp": 1773033669.2808225, - "vms_running": 208, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 12.575054168701172, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 208, - "firecracker_rss_mb": 9759.08203125, - "fc_socket_count": 208, - "sqlite_db_kb": 248.0 - }, - { - "event": "boot_ok", - "vm_seq": 209, - "boot_time_s": 3.191, - "density_at_boot": 209, - "timestamp": 1773033672.6431203, - "vms_running": 209, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.619369506835938, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 209, - "firecracker_rss_mb": 9805.75390625, - "fc_socket_count": 209, - "sqlite_db_kb": 248.0 - }, - { - "event": "boot_ok", - "vm_seq": 210, - "boot_time_s": 2.493, - "density_at_boot": 210, - "timestamp": 1773033675.3110383, - "vms_running": 210, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 12.677513122558594, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 210, - "firecracker_rss_mb": 9852.9375, - "fc_socket_count": 210, - "sqlite_db_kb": 248.0 - }, - { - "event": "boot_ok", - "vm_seq": 211, - "boot_time_s": 3.235, - "density_at_boot": 211, - "timestamp": 1773033678.7220268, - "vms_running": 211, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.724494934082031, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 211, - "firecracker_rss_mb": 9900.1171875, - "fc_socket_count": 211, - "sqlite_db_kb": 252.0 - }, - { - "event": "boot_ok", - "vm_seq": 212, - "boot_time_s": 3.18, - "density_at_boot": 212, - "timestamp": 1773033682.0824926, - "vms_running": 212, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.762870788574219, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 212, - "firecracker_rss_mb": 9946.78125, - "fc_socket_count": 212, - "sqlite_db_kb": 252.0 - }, - { - "event": "boot_ok", - "vm_seq": 213, - "boot_time_s": 3.265, - "density_at_boot": 213, - "timestamp": 1773033685.5220332, - "vms_running": 213, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.811355590820312, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 213, - "firecracker_rss_mb": 9993.70703125, - "fc_socket_count": 213, - "sqlite_db_kb": 252.0 - }, - { - "event": "boot_ok", - "vm_seq": 214, - "boot_time_s": 2.224, - "density_at_boot": 214, - "timestamp": 1773033687.9207778, - "vms_running": 214, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.849857330322266, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 214, - "firecracker_rss_mb": 10040.37890625, - "fc_socket_count": 214, - "sqlite_db_kb": 252.0 - }, - { - "event": "boot_ok", - "vm_seq": 215, - "boot_time_s": 3.185, - "density_at_boot": 215, - "timestamp": 1773033691.2841442, - "vms_running": 215, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.905830383300781, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 215, - "firecracker_rss_mb": 10087.30859375, - "fc_socket_count": 215, - "sqlite_db_kb": 252.0 - }, - { - "event": "boot_ok", - "vm_seq": 216, - "boot_time_s": 2.32, - "density_at_boot": 216, - "timestamp": 1773033693.7820256, - "vms_running": 216, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 12.955081939697266, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 216, - "firecracker_rss_mb": 10133.72265625, - "fc_socket_count": 216, - "sqlite_db_kb": 256.0 - }, - { - "event": "boot_ok", - "vm_seq": 217, - "boot_time_s": 3.163, - "density_at_boot": 217, - "timestamp": 1773033697.1216776, - "vms_running": 217, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 12.997241973876953, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 217, - "firecracker_rss_mb": 10180.6484375, - "fc_socket_count": 217, - "sqlite_db_kb": 264.0 - }, - { - "event": "boot_ok", - "vm_seq": 218, - "boot_time_s": 3.265, - "density_at_boot": 218, - "timestamp": 1773033700.5650856, - "vms_running": 218, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 13.045398712158203, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 218, - "firecracker_rss_mb": 10227.83203125, - "fc_socket_count": 218, - "sqlite_db_kb": 264.0 - }, - { - "event": "boot_ok", - "vm_seq": 219, - "boot_time_s": 2.279, - "density_at_boot": 219, - "timestamp": 1773033703.022103, - "vms_running": 219, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 13.093620300292969, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 219, - "firecracker_rss_mb": 10275.2734375, - "fc_socket_count": 219, - "sqlite_db_kb": 264.0 - }, - { - "event": "boot_ok", - "vm_seq": 220, - "boot_time_s": 2.433, - "density_at_boot": 220, - "timestamp": 1773033705.6311026, - "vms_running": 220, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 13.141223907470703, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 220, - "firecracker_rss_mb": 10322.19921875, - "fc_socket_count": 220, - "sqlite_db_kb": 264.0 - }, - { - "event": "boot_ok", - "vm_seq": 221, - "boot_time_s": 3.156, - "density_at_boot": 221, - "timestamp": 1773033708.9627576, - "vms_running": 221, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 13.182518005371094, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 221, - "firecracker_rss_mb": 10368.8671875, - "fc_socket_count": 221, - "sqlite_db_kb": 272.0 - }, - { - "event": "boot_ok", - "vm_seq": 222, - "boot_time_s": 2.405, - "density_at_boot": 222, - "timestamp": 1773033711.541123, - "vms_running": 222, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 13.22659683227539, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 222, - "firecracker_rss_mb": 10415.53515625, - "fc_socket_count": 222, - "sqlite_db_kb": 312.0 - }, - { - "event": "boot_ok", - "vm_seq": 223, - "boot_time_s": 2.305, - "density_at_boot": 223, - "timestamp": 1773033714.0210059, - "vms_running": 223, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 13.278278350830078, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 223, - "firecracker_rss_mb": 10462.4609375, - "fc_socket_count": 223, - "sqlite_db_kb": 312.0 - }, - { - "event": "boot_ok", - "vm_seq": 224, - "boot_time_s": 3.239, - "density_at_boot": 224, - "timestamp": 1773033717.4414132, - "vms_running": 224, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 13.334373474121094, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 224, - "firecracker_rss_mb": 10509.1328125, - "fc_socket_count": 224, - "sqlite_db_kb": 312.0 - }, - { - "event": "boot_ok", - "vm_seq": 225, - "boot_time_s": 2.319, - "density_at_boot": 225, - "timestamp": 1773033719.9409328, - "vms_running": 225, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 13.38070297241211, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 225, - "firecracker_rss_mb": 10555.8046875, - "fc_socket_count": 225, - "sqlite_db_kb": 312.0 - }, - { - "event": "boot_ok", - "vm_seq": 226, - "boot_time_s": 3.323, - "density_at_boot": 226, - "timestamp": 1773033723.4444726, - "vms_running": 226, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 13.42630386352539, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 226, - "firecracker_rss_mb": 10602.7265625, - "fc_socket_count": 226, - "sqlite_db_kb": 316.0 - }, - { - "event": "boot_ok", - "vm_seq": 227, - "boot_time_s": 3.176, - "density_at_boot": 227, - "timestamp": 1773033726.8020544, - "vms_running": 227, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 13.469928741455078, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 227, - "firecracker_rss_mb": 10649.390625, - "fc_socket_count": 227, - "sqlite_db_kb": 316.0 - }, - { - "event": "boot_ok", - "vm_seq": 228, - "boot_time_s": 3.187, - "density_at_boot": 228, - "timestamp": 1773033730.1644514, - "vms_running": 228, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 13.523738861083984, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 228, - "firecracker_rss_mb": 10696.3203125, - "fc_socket_count": 228, - "sqlite_db_kb": 316.0 - }, - { - "event": "boot_ok", - "vm_seq": 229, - "boot_time_s": 3.262, - "density_at_boot": 229, - "timestamp": 1773033733.6042023, - "vms_running": 229, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 13.56546401977539, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 229, - "firecracker_rss_mb": 10743.50390625, - "fc_socket_count": 229, - "sqlite_db_kb": 316.0 - }, - { - "event": "boot_ok", - "vm_seq": 230, - "boot_time_s": 3.259, - "density_at_boot": 230, - "timestamp": 1773033737.0411217, - "vms_running": 230, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 13.606185913085938, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 230, - "firecracker_rss_mb": 10790.16796875, - "fc_socket_count": 230, - "sqlite_db_kb": 316.0 - }, - { - "event": "boot_ok", - "vm_seq": 231, - "boot_time_s": 3.261, - "density_at_boot": 231, - "timestamp": 1773033740.4821775, - "vms_running": 231, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 13.671470642089844, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 231, - "firecracker_rss_mb": 10837.09765625, - "fc_socket_count": 231, - "sqlite_db_kb": 320.0 - }, - { - "event": "boot_ok", - "vm_seq": 232, - "boot_time_s": 3.175, - "density_at_boot": 232, - "timestamp": 1773033743.8407533, - "vms_running": 232, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 13.712615966796875, - "host_disk_used_gb": 2.0682449340820312, - "tap_count": 232, - "firecracker_rss_mb": 10884.0234375, - "fc_socket_count": 232, - "sqlite_db_kb": 320.0 - }, - { - "event": "boot_ok", - "vm_seq": 233, - "boot_time_s": 3.221, - "density_at_boot": 233, - "timestamp": 1773033747.2403154, - "vms_running": 233, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 13.756458282470703, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 233, - "firecracker_rss_mb": 10930.94921875, - "fc_socket_count": 233, - "sqlite_db_kb": 320.0 - }, - { - "event": "boot_ok", - "vm_seq": 234, - "boot_time_s": 2.28, - "density_at_boot": 234, - "timestamp": 1773033749.7022865, - "vms_running": 234, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 13.799877166748047, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 234, - "firecracker_rss_mb": 10978.13671875, - "fc_socket_count": 234, - "sqlite_db_kb": 324.0 - }, - { - "event": "boot_ok", - "vm_seq": 235, - "boot_time_s": 3.32, - "density_at_boot": 235, - "timestamp": 1773033753.2051058, - "vms_running": 235, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 13.846595764160156, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 235, - "firecracker_rss_mb": 11024.80859375, - "fc_socket_count": 235, - "sqlite_db_kb": 324.0 - }, - { - "event": "boot_ok", - "vm_seq": 236, - "boot_time_s": 3.259, - "density_at_boot": 236, - "timestamp": 1773033756.6450055, - "vms_running": 236, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 13.88980484008789, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 236, - "firecracker_rss_mb": 11071.734375, - "fc_socket_count": 236, - "sqlite_db_kb": 328.0 - }, - { - "event": "boot_ok", - "vm_seq": 237, - "boot_time_s": 3.262, - "density_at_boot": 237, - "timestamp": 1773033760.0850143, - "vms_running": 237, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 13.9407958984375, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 237, - "firecracker_rss_mb": 11118.40234375, - "fc_socket_count": 237, - "sqlite_db_kb": 328.0 - }, - { - "event": "boot_ok", - "vm_seq": 238, - "boot_time_s": 3.258, - "density_at_boot": 238, - "timestamp": 1773033763.5224333, - "vms_running": 238, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 13.986568450927734, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 238, - "firecracker_rss_mb": 11165.5859375, - "fc_socket_count": 238, - "sqlite_db_kb": 328.0 - }, - { - "event": "boot_ok", - "vm_seq": 239, - "boot_time_s": 3.257, - "density_at_boot": 239, - "timestamp": 1773033766.9620733, - "vms_running": 239, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 14.035202026367188, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 239, - "firecracker_rss_mb": 11212.25390625, - "fc_socket_count": 239, - "sqlite_db_kb": 328.0 - }, - { - "event": "boot_ok", - "vm_seq": 240, - "boot_time_s": 3.34, - "density_at_boot": 240, - "timestamp": 1773033770.482531, - "vms_running": 240, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 14.085208892822266, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 240, - "firecracker_rss_mb": 11259.18359375, - "fc_socket_count": 240, - "sqlite_db_kb": 328.0 - }, - { - "event": "boot_ok", - "vm_seq": 241, - "boot_time_s": 2.274, - "density_at_boot": 241, - "timestamp": 1773033772.939943, - "vms_running": 241, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 14.136260986328125, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 241, - "firecracker_rss_mb": 11305.6015625, - "fc_socket_count": 241, - "sqlite_db_kb": 332.0 - }, - { - "event": "boot_ok", - "vm_seq": 242, - "boot_time_s": 3.284, - "density_at_boot": 242, - "timestamp": 1773033776.4048007, - "vms_running": 242, - "host_cpu_pct": 0.6, - "host_mem_used_gb": 14.17977523803711, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 242, - "firecracker_rss_mb": 11352.2734375, - "fc_socket_count": 242, - "sqlite_db_kb": 332.0 - }, - { - "event": "boot_ok", - "vm_seq": 243, - "boot_time_s": 2.318, - "density_at_boot": 243, - "timestamp": 1773033778.9048815, - "vms_running": 243, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 14.225570678710938, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 243, - "firecracker_rss_mb": 11399.97265625, - "fc_socket_count": 243, - "sqlite_db_kb": 332.0 - }, - { - "event": "boot_ok", - "vm_seq": 244, - "boot_time_s": 3.241, - "density_at_boot": 244, - "timestamp": 1773033782.3236187, - "vms_running": 244, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 14.274162292480469, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 244, - "firecracker_rss_mb": 11446.90234375, - "fc_socket_count": 244, - "sqlite_db_kb": 332.0 - }, - { - "event": "boot_ok", - "vm_seq": 245, - "boot_time_s": 3.412, - "density_at_boot": 245, - "timestamp": 1773033785.9220474, - "vms_running": 245, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 14.318473815917969, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 245, - "firecracker_rss_mb": 11493.3125, - "fc_socket_count": 245, - "sqlite_db_kb": 332.0 - }, - { - "event": "boot_ok", - "vm_seq": 246, - "boot_time_s": 3.255, - "density_at_boot": 246, - "timestamp": 1773033789.3639004, - "vms_running": 246, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 14.37160873413086, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 246, - "firecracker_rss_mb": 11539.7265625, - "fc_socket_count": 246, - "sqlite_db_kb": 336.0 - }, - { - "event": "boot_ok", - "vm_seq": 247, - "boot_time_s": 3.259, - "density_at_boot": 247, - "timestamp": 1773033792.8039594, - "vms_running": 247, - "host_cpu_pct": 0.4, - "host_mem_used_gb": 14.427932739257812, - "host_disk_used_gb": 2.0760574340820312, - "tap_count": 247, - "firecracker_rss_mb": 11586.65234375, - "fc_socket_count": 247, - "sqlite_db_kb": 336.0 - }, - { - "event": "boot_ok", - "vm_seq": 248, - "boot_time_s": 3.26, - "density_at_boot": 248, - "timestamp": 1773033796.244873, - "vms_running": 248, - "host_cpu_pct": 0.1, - "host_mem_used_gb": 14.464420318603516, - "host_disk_used_gb": 2.074138641357422, - "tap_count": 248, - "firecracker_rss_mb": 11633.32421875, - "fc_socket_count": 248, - "sqlite_db_kb": 336.0 - }, - { - "event": "boot_ok", - "vm_seq": 249, - "boot_time_s": 3.26, - "density_at_boot": 249, - "timestamp": 1773033799.6849911, - "vms_running": 249, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 14.509002685546875, - "host_disk_used_gb": 2.074169158935547, - "tap_count": 249, - "firecracker_rss_mb": 11680.25, - "fc_socket_count": 249, - "sqlite_db_kb": 336.0 - }, - { - "event": "boot_ok", - "vm_seq": 250, - "boot_time_s": 3.131, - "density_at_boot": 250, - "timestamp": 1773033803.0008395, - "vms_running": 250, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 14.562793731689453, - "host_disk_used_gb": 2.074230194091797, - "tap_count": 250, - "firecracker_rss_mb": 11727.43359375, - "fc_socket_count": 250, - "sqlite_db_kb": 336.0 - }, - { - "event": "boot_ok", - "vm_seq": 251, - "boot_time_s": 3.217, - "density_at_boot": 251, - "timestamp": 1773033806.4029758, - "vms_running": 251, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 14.611839294433594, - "host_disk_used_gb": 2.0742530822753906, - "tap_count": 251, - "firecracker_rss_mb": 11774.62109375, - "fc_socket_count": 251, - "sqlite_db_kb": 340.0 - }, - { - "event": "boot_ok", - "vm_seq": 252, - "boot_time_s": 3.417, - "density_at_boot": 252, - "timestamp": 1773033810.0056808, - "vms_running": 252, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 14.651336669921875, - "host_disk_used_gb": 2.0743331909179688, - "tap_count": 252, - "firecracker_rss_mb": 11822.0625, - "fc_socket_count": 252, - "sqlite_db_kb": 340.0 - }, - { - "event": "boot_ok", - "vm_seq": 253, - "boot_time_s": 3.25, - "density_at_boot": 253, - "timestamp": 1773033813.440772, - "vms_running": 253, - "host_cpu_pct": 0.2, - "host_mem_used_gb": 14.702342987060547, - "host_disk_used_gb": 2.0743141174316406, - "tap_count": 253, - "firecracker_rss_mb": 11868.73046875, - "fc_socket_count": 253, - "sqlite_db_kb": 340.0 - }, - { - "event": "sustain_check", - "sustain_sec": 60, - "vms_alive": 253, - "vms_dead": [], - "vms_checked": 253, - "timestamp": 1773033874.0488198, - "vms_running": 253, - "host_cpu_pct": 0.3, - "host_mem_used_gb": 14.580455780029297, - "host_disk_used_gb": 2.074298858642578, - "tap_count": 253, - "firecracker_rss_mb": 11942.98046875, - "fc_socket_count": 253, - "sqlite_db_kb": 340.0 - }, - { - "event": "teardown", - "teardown_time_s": 127.52, - "timestamp": 1773034001.7450569, - "vms_running": 0, - "host_cpu_pct": 0.0, - "host_mem_used_gb": 3.0937042236328125, - "host_disk_used_gb": 2.0742874145507812, - "tap_count": 253, - "firecracker_rss_mb": 0.0, - "fc_socket_count": 0, - "sqlite_db_kb": 340.0 - } -] \ No newline at end of file From 1869549e92a9d4f7bf1a1aa7fbf82b8feb9a9e26 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:32:37 -0400 Subject: [PATCH 16/20] benchmarks: apply EC2 hardening to GCP density ramp script Port Docker/nftables install, ulimit/sysctl tuning (nofile, nproc, ip_local_port_range, somaxconn), and post-run network/log diagnostics from run_density_ramp_ec2.sh to run_density_ramp_gcp.sh, adapted for Debian 12 (apt-get, docker.io package, no firewalld). Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/run_density_ramp_gcp.sh | 45 ++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/benchmarks/run_density_ramp_gcp.sh b/benchmarks/run_density_ramp_gcp.sh index 8f03759..5dbba31 100755 --- a/benchmarks/run_density_ramp_gcp.sh +++ b/benchmarks/run_density_ramp_gcp.sh @@ -212,9 +212,20 @@ set -euo pipefail sudo usermod -aG kvm "$USER" || true sudo setfacl -m u:"$USER":rw /dev/kvm 2>/dev/null || sudo chmod 666 /dev/kvm -# Install Python and pip +# Raise open-file and process limits for high-density VM runs +echo "$USER soft nofile 65536" | sudo tee -a /etc/security/limits.conf +echo "$USER hard nofile 65536" | sudo tee -a /etc/security/limits.conf +echo "$USER soft nproc 65536" | sudo tee -a /etc/security/limits.conf +echo "$USER hard nproc 65536" | sudo tee -a /etc/security/limits.conf +# Allow a large number of concurrent TCP connections +sudo sysctl -w net.ipv4.ip_local_port_range="1024 65535" >/dev/null +sudo sysctl -w net.core.somaxconn=65535 >/dev/null + +# Install Python, pip, Docker, and nftables sudo apt-get update -qq -sudo apt-get install -y -qq python3 python3-pip python3-venv +sudo apt-get install -y -qq python3 python3-pip python3-venv docker.io nftables +sudo systemctl start docker +sudo usermod -aG docker "$USER" # Install smolvm and psutil into a venv (avoids PEP 668 externally-managed-env error) python3 -m venv ~/venv @@ -260,6 +271,36 @@ echo "" echo "WARNING: Benchmark exited with a non-zero status (may be expected at resource limit)." } +# --------------------------------------------------------------------------- +# Post-run diagnostics (network state + first VM log) +# --------------------------------------------------------------------------- +echo "" +echo "--- Post-run diagnostics ---" +"${GSSH[@]}" --command="bash -s" <<'DIAG' || true +set -uo pipefail + +echo "=== Network interfaces (TAP devices) ===" +ip -o link show | grep -E "tap|lo|eth" || true + +echo "" +echo "=== Routes ===" +ip route show + +echo "" +echo "=== nftables ruleset ===" +sudo nft list ruleset 2>/dev/null || echo "(nft list failed)" + +echo "" +echo "=== Most recent Firecracker VM log (last 60 lines) ===" +LOG=$(ls -t ~/.local/state/smolvm/vm-*.log 2>/dev/null | head -1) +if [ -n "$LOG" ]; then + echo "Log: $LOG" + tail -60 "$LOG" +else + echo "(no VM log files found under ~/.local/state/smolvm/)" +fi +DIAG + # --------------------------------------------------------------------------- # Collect results # --------------------------------------------------------------------------- From 953965ca1039da8668e0a37d591998fca9147506 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:40:44 -0400 Subject: [PATCH 17/20] benchmarks: skip failed HTTP/SSE samples in network IO benchmark Only append timing measurements when curl/vm.run succeeds (returncode==0 and non-empty stdout). Failed requests due to network issues or startup races previously produced invalid latency data; now they are logged as warnings and excluded from stats_summary. Fixes CodeRabbit discussion_r2903439531. Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/bench_network_io.py | 44 +++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 14 deletions(-) diff --git a/benchmarks/bench_network_io.py b/benchmarks/bench_network_io.py index 272919e..acf95f9 100644 --- a/benchmarks/bench_network_io.py +++ b/benchmarks/bench_network_io.py @@ -103,14 +103,16 @@ def run_benchmark() -> dict: print_subheader("Host: HTTP request to localhost") host_http_times = [] for _ in range(100): - t = time_call( - lambda: subprocess.run( + with timer() as t: + proc = subprocess.run( ["curl", "-s", f"http://127.0.0.1:{host_port}/health"], capture_output=True, timeout=5, ) - ) - host_http_times.append(t) + if proc.returncode == 0 and proc.stdout: + host_http_times.append(t.elapsed_ms) + else: + print(f" [warn] curl failed (rc={proc.returncode}), skipping sample") host_http_stats = stats_summary(host_http_times) print_result("Stats (100 iters)", format_stats(host_http_stats)) results["host_http"] = host_http_stats @@ -125,10 +127,15 @@ def run_benchmark() -> dict: timeout=10, ) host_sse_lines = result.stdout.count("data:") - print_result("Duration", f"{t.elapsed_ms:.0f}ms") - print_result("Events received", str(host_sse_lines)) - results["host_sse_ms"] = t.elapsed_ms - results["host_sse_events"] = host_sse_lines + if result.returncode == 0 and host_sse_lines > 0: + print_result("Duration", f"{t.elapsed_ms:.0f}ms") + print_result("Events received", str(host_sse_lines)) + results["host_sse_ms"] = t.elapsed_ms + results["host_sse_events"] = host_sse_lines + else: + print(f" [warn] SSE curl failed (rc={result.returncode}, events={host_sse_lines}), skipping") + results["host_sse_ms"] = None + results["host_sse_events"] = host_sse_lines # now we bench SmolVM print_subheader("SmolVM: Starting VM start up") @@ -189,8 +196,12 @@ def run_benchmark() -> dict: print_subheader("SmolVM: HTTP request (VM -> host)") vm_http_times = [] for _ in range(100): - t = time_call(lambda: vm.run(fetch_cmd, timeout=10)) - vm_http_times.append(t) + with timer() as t: + r = vm.run(fetch_cmd, timeout=10) + if r.returncode == 0 and r.stdout.strip(): + vm_http_times.append(t.elapsed_ms) + else: + print(f" [warn] VM HTTP request failed (rc={r.returncode}), skipping sample") vm_http_stats = stats_summary(vm_http_times) print_result("Stats (100 iters)", format_stats(vm_http_stats)) results["vm_http"] = vm_http_stats @@ -204,10 +215,15 @@ def run_benchmark() -> dict: timeout=15, ) vm_sse_lines = sse_result.stdout.count("data:") - print_result("Duration", f"{t.elapsed_ms:.0f}ms") - print_result("Events received", str(vm_sse_lines)) - results["vm_sse_ms"] = t.elapsed_ms - results["vm_sse_events"] = vm_sse_lines + if sse_result.returncode == 0 and vm_sse_lines > 0: + print_result("Duration", f"{t.elapsed_ms:.0f}ms") + print_result("Events received", str(vm_sse_lines)) + results["vm_sse_ms"] = t.elapsed_ms + results["vm_sse_events"] = vm_sse_lines + else: + print(f" [warn] VM SSE failed (rc={sse_result.returncode}, events={vm_sse_lines}), skipping") + results["vm_sse_ms"] = None + results["vm_sse_events"] = vm_sse_lines else: print("\n Skipping SSE test (curl not available in VM)") results["vm_sse_ms"] = None From 41dce88319ad28ff0ad95607984b259bf6fecec4 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:43:14 -0400 Subject: [PATCH 18/20] fix: add missing os import in build.py for uid/gid preservation os.getuid() and os.getgid() were called in _create_ext4_with_docker() but the os module was not imported, causing a NameError at runtime. Fixes CodeRabbit discussion_r2903439577. Co-Authored-By: Claude Sonnet 4.6 --- src/smolvm/build.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/smolvm/build.py b/src/smolvm/build.py index e472108..5706c4c 100644 --- a/src/smolvm/build.py +++ b/src/smolvm/build.py @@ -20,6 +20,7 @@ import hashlib import json import logging +import os import platform import re import shlex From 74bbdfe0437d45ea7f114317a60b9b82d2a8b4c6 Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:44:51 -0400 Subject: [PATCH 19/20] benchmarks: surface vm.delete() failures on boot-error path Previously, cleanup errors were silently swallowed (except Exception: pass), hiding leaked disks/sockets near the resource ceiling. Now cleanup_error is captured and included in the returned error dict so callers and snapshots can see delete failures. Fixes CodeRabbit discussion_r2903439539. Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/density_ramp.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/benchmarks/density_ramp.py b/benchmarks/density_ramp.py index ab61d48..4db7806 100644 --- a/benchmarks/density_ramp.py +++ b/benchmarks/density_ramp.py @@ -185,12 +185,13 @@ def boot_one( return vm, time.time() - start_t, {} except Exception as e: fc_log = _read_vm_log(vm) if vm is not None else "(VM object not created)" + err: dict[str, Any] = {"error": str(e), "fc_log": fc_log} if vm is not None: try: vm.delete() - except Exception: - pass - return None, time.time() - start_t, {"error": str(e), "fc_log": fc_log} + except Exception as cleanup_exc: + err["cleanup_error"] = str(cleanup_exc) + return None, time.time() - start_t, err def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: From 2e8710cdfae20f6a66b1c7c6da2822e61de8dfda Mon Sep 17 00:00:00 2001 From: Craig Pfeifer Date: Mon, 9 Mar 2026 02:47:04 -0400 Subject: [PATCH 20/20] benchmarks: preserve launch order and fix density counts in parallel mode boot_one() now returns seq as the first element of its tuple so callers can use the original launch index instead of completion order. In the as_completed() loop, batch_ok_so_far tracks successful boots within the batch so density_at_boot reflects the true concurrent count for each VM (not just len(running_vms)+1 for all). batch_results are sorted by seq before processing to emit boot_ok/boot_fail records in launch order. Fixes CodeRabbit discussion_r2903439537. Co-Authored-By: Claude Sonnet 4.6 --- benchmarks/density_ramp.py | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/benchmarks/density_ramp.py b/benchmarks/density_ramp.py index 4db7806..68b91ca 100644 --- a/benchmarks/density_ramp.py +++ b/benchmarks/density_ramp.py @@ -164,8 +164,8 @@ def boot_one( disk_mode: str, backend: str | None, socket_dir: Path, -) -> tuple[SmolVM | None, float, dict[str, Any]]: - """Boot a single VM. Returns (vm_or_None, boot_seconds, error_dict).""" +) -> tuple[int, SmolVM | None, float, dict[str, Any]]: + """Boot a single VM. Returns (seq, vm_or_None, boot_seconds, error_dict).""" start_t = time.time() vm: SmolVM | None = None try: @@ -182,7 +182,7 @@ def boot_one( vm = SmolVM(config, ssh_key_path=ssh_key_path, socket_dir=socket_dir) vm.start() vm.wait_for_ssh(timeout=30.0) - return vm, time.time() - start_t, {} + return seq, vm, time.time() - start_t, {} except Exception as e: fc_log = _read_vm_log(vm) if vm is not None else "(VM object not created)" err: dict[str, Any] = {"error": str(e), "fc_log": fc_log} @@ -191,7 +191,7 @@ def boot_one( vm.delete() except Exception as cleanup_exc: err["cleanup_error"] = str(cleanup_exc) - return None, time.time() - start_t, err + return seq, None, time.time() - start_t, err def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: @@ -285,11 +285,12 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: batch_size = min(args.parallel, args.max_attempts - i) # Boot one batch (serial or parallel). - # Each result is a 4-tuple (vm, boot_t, err, snap) where snap is - # captured immediately when the boot completes — not post-batch — + # Each result is a 5-tuple (seq, vm, boot_t, err, snap) where snap + # is captured immediately when the boot completes — not post-batch — # so parallel runs record per-VM resource state accurately. + # Results are sorted by seq before processing to preserve launch order. if batch_size == 1: - vm, boot_t, err = boot_one( + seq_r, vm, boot_t, err = boot_one( i + 1, kernel, rootfs, @@ -300,7 +301,7 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: args.socket_dir, ) density = len(running_vms) + (1 if vm is not None else 0) - batch_results = [(vm, boot_t, err, Metrics.snapshot(density, args.socket_dir))] + batch_results = [(seq_r, vm, boot_t, err, Metrics.snapshot(density, args.socket_dir))] else: with ThreadPoolExecutor(max_workers=batch_size) as ex: futures = [ @@ -318,20 +319,23 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: for j in range(batch_size) ] batch_results = [] + batch_ok_so_far = 0 for f in as_completed(futures): - vm, boot_t, err = f.result() - density = len(running_vms) + (1 if vm is not None else 0) + seq_r, vm, boot_t, err = f.result() + if vm is not None: + batch_ok_so_far += 1 + density = len(running_vms) + batch_ok_so_far snap = Metrics.snapshot(density, args.socket_dir) - batch_results.append((vm, boot_t, err, snap)) + batch_results.append((seq_r, vm, boot_t, err, snap)) failed_this_batch = 0 - for vm, boot_t, err, snap in batch_results: + for seq_r, vm, boot_t, err, snap in sorted(batch_results): i += 1 if vm is not None: running_vms.append(vm) print( - f"VM {i}: boot={boot_t:.2f}s | " + f"VM {seq_r}: boot={boot_t:.2f}s | " f"mem={snap.host_mem_used_gb:.2f}GB " f"disk={snap.host_disk_used_gb:.2f}GB " f"tap={snap.tap_count} " @@ -340,14 +344,14 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: results.append( { "event": "boot_ok", - "vm_seq": i, + "vm_seq": seq_r, "boot_time_s": round(boot_t, 3), "density_at_boot": len(running_vms), **asdict(snap), } ) else: - print(f"FAIL @ VM {i}: {err.get('error', '?')}") + print(f"FAIL @ VM {seq_r}: {err.get('error', '?')}") if not _diag_printed and err.get("fc_log"): _diag_printed = True print("--- Firecracker log (first failure) ---") @@ -356,7 +360,7 @@ def check_vm_alive(vm: SmolVM, seq: int) -> tuple[int, bool, str]: results.append( { "event": "boot_fail", - "vm_seq": i, + "vm_seq": seq_r, **err, **asdict(snap), }