tzf-rs 1.2.0

Fast convert longitude,latitude to timezone name.
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

import platform
import re
from pathlib import Path

SCENARIO_MAP = {
    "YStripesOnly": "YStripes only",
    "NoIndex": "No index",
}

MODE_MAP = {
    "YStripesOnly": "ystripes",
    "NoIndex": "noindex",
}

CONFIG_MAP = {
    "YStripesOnly": "`enable_y_stripes=true`",
    "NoIndex": "`enable_y_stripes=false`",
}

TARGETS = [
    ("Finder", "FinderIndexModes", "finder"),
    ("DefaultFinder", "DefaultFinderIndexModes", "default"),
]

SCENARIOS = ["YStripesOnly", "NoIndex"]


def parse_peak_bytes(path: Path, is_darwin: bool) -> int:
    txt = path.read_text()
    if is_darwin:
        match = re.search(r"\n\s*(\d+)\s+maximum resident set size", txt)
        if not match:
            raise RuntimeError(f"cannot parse macOS RSS from {path}")
        return int(match.group(1))

    match = re.search(r"Maximum resident set size \(kbytes\):\s*(\d+)", txt)
    if not match:
        raise RuntimeError(f"cannot parse Linux RSS from {path}")
    return int(match.group(1)) * 1024


def parse_range_us(bench_text: str, target_group: str, scenario: str):
    pattern = rf"{re.escape(target_group)}/{re.escape(scenario)}/0[\s\S]*?time:\s*\[([^\]]+)\]"
    match = re.search(pattern, bench_text)
    if not match:
        return None

    values = []
    for number, unit in re.findall(r"([0-9]+\.[0-9]+)\s*(ns|µs|ms)", match.group(1)):
        value = float(number)
        if unit == "ns":
            value /= 1000.0
        elif unit == "ms":
            value *= 1000.0
        values.append(value)

    if len(values) != 3:
        return None
    return values


def fmt_float(value: float, ndigits: int = 4) -> str:
    return f"{value:.{ndigits}f}"


def fmt_int(value: float) -> str:
    return f"{int(round(value)):,}"


def build_rows(bench_text: str, runs: int = 5):
    rows = []
    is_darwin = platform.system() == "Darwin"

    for target_name, target_group, target_key in TARGETS:
        for scenario in SCENARIOS:
            range_us = parse_range_us(bench_text, target_group, scenario)
            if range_us is None:
                continue

            median = range_us[1]
            throughput = 1_000_000.0 / median
            mode = MODE_MAP[scenario]

            rss_values = []
            for i in range(1, runs + 1):
                path = Path(f"/tmp/tzf_mem_{target_key}_{mode}_{i}.time")
                rss_values.append(parse_peak_bytes(path, is_darwin))

            avg_mib = sum(rss_values) / len(rss_values) / 1024 / 1024

            rows.append(
                (
                    target_name,
                    SCENARIO_MAP[scenario],
                    CONFIG_MAP[scenario],
                    f"[{fmt_float(range_us[0])}, {fmt_float(range_us[1])}, {fmt_float(range_us[2])}]",
                    fmt_float(median),
                    fmt_int(throughput),
                    f"{avg_mib:.2f}",
                    ", ".join(str(v) for v in rss_values),
                )
            )

    return rows