falkordb 0.10.3

A FalkorDB Rust client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#!/usr/bin/env python3
"""Parse criterion estimates from the async_strategies benchmark and write
blog/data/benchmarks.toml — a dated sample run with provenance metadata.

Invoked by scripts/bench-export.sh (`just bench-export`). Reads the mean point estimate
(nanoseconds per iteration) criterion writes for each benchmark id and renders a small
pooled-vs-multiplexed table for connection count 8. Not a CI gate — numbers are illustrative
and reproducible with `just bench`.
"""

from __future__ import annotations

import datetime
import json
import os
import platform
import subprocess

ROOT = os.getcwd()
GROUP_DIR = os.path.join(ROOT, "target", "criterion", "async_read_throughput")
CONCURRENCIES = [1, 8, 64, 256]
OUT = os.path.join(ROOT, "blog", "data", "benchmarks.toml")


def mean_ns(function_id: str, param: int) -> float | None:
    path = os.path.join(GROUP_DIR, function_id, str(param), "new", "estimates.json")
    try:
        with open(path) as fh:
            return json.load(fh)["mean"]["point_estimate"]
    except (FileNotFoundError, KeyError, json.JSONDecodeError):
        return None


def fmt_time(ns: float) -> str:
    us = ns / 1_000.0
    if us >= 1_000.0:
        return f"{us / 1_000.0:.2f} ms"
    return f"{us:.1f} \u00b5s"  # microseconds


def sh(cmd: list[str], default: str = "") -> str:
    """Run a command (no shell) and return its stripped stdout, or `default` on any failure."""
    try:
        return subprocess.check_output(cmd, text=True).strip() or default
    except (OSError, subprocess.SubprocessError):
        return default


def cpu_model() -> str:
    if platform.system() == "Darwin":
        return sh(["sysctl", "-n", "machdep.cpu.brand_string"], "Apple silicon")
    try:
        with open("/proc/cpuinfo") as fh:
            for line in fh:
                if line.startswith("model name"):
                    return line.split(":", 1)[1].strip()
    except OSError:
        # /proc/cpuinfo is Linux-only and may be unreadable; fall back to platform.processor() below.
        pass
    return platform.processor() or "unknown CPU"


def toml_escape(value: str) -> str:
    return value.replace("\\", "\\\\").replace('"', '\\"')


def main() -> None:
    rows: list[tuple[str, str, str, str]] = []
    for c in CONCURRENCIES:
        pooled = mean_ns("pooled_8", c)
        mux = mean_ns("multiplexed_8", c)
        if pooled is None or mux is None:
            continue
        speedup = pooled / mux if mux else 0.0
        rows.append((str(c), fmt_time(pooled), fmt_time(mux), f"{speedup:.2f}\u00d7"))

    if not rows:
        raise SystemExit(
            "bench_export: no criterion estimates found under target/criterion/"
            "async_read_throughput/ — did the benchmark run against a server?"
        )

    image = sh(["docker", "inspect", "--format", "{{index .RepoDigests 0}}", "falkordb/falkordb:edge"],
               "falkordb/falkordb:edge")
    meta = {
        "date": datetime.date.today().isoformat(),
        "commit": sh(["git", "rev-parse", "--short", "HEAD"], "unknown"),
        "falkordb_image": image,
        "cpu": cpu_model(),
        "os": f"{platform.system()} {platform.machine()}",
        "criterion": "0.8",
    }

    lines = [
        "# Benchmark sample-run data rendered by the `bench_table` shortcode.",
        "# Regenerated by `just bench-export` (scripts/bench-export.sh + bench_export.py).",
        "# A dated SAMPLE RUN with provenance — NOT an exact-match CI gate. Reproduce with",
        "# `just bench`.",
        "",
        "[meta]",
    ]
    for key, value in meta.items():
        lines.append(f'{key} = "{toml_escape(value)}"')
    lines += [
        "",
        "[async_strategies]",
        'title = "Async read throughput at 8 connections — pooled vs multiplexed"',
        'headers = ["Concurrent reads", "Pooled (mean)", "Multiplexed (mean)", "Speedup"]',
        "rows = [",
    ]
    for row in rows:
        cells = ", ".join(f'"{toml_escape(cell)}"' for cell in row)
        lines.append(f"    [{cells}],")
    lines += ["]", ""]

    with open(OUT, "w") as fh:
        fh.write("\n".join(lines))
    print(f"bench_export: wrote {OUT} ({len(rows)} row(s))")


if __name__ == "__main__":
    main()