Source: mtusi2026lab4-safronov, solution/bvt2301-safronov, 2546deb. Contracts, public tests and evidence of lab 4 are not carried over. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
793 lines
32 KiB
Python
793 lines
32 KiB
Python
"""Сравнение двух меток стенда: дельта по ячейкам матрицы.
|
||
|
||
Запуск — `make bench_compare BEFORE=<метка> AFTER=<метка> [AA=<метка>]`.
|
||
Читает `runs.csv` и `meta.json` из `evidence/bench/<метка>/`, пишет
|
||
`evidence/compare/<до>__<после>.md`. Только stdlib, docker и приложение
|
||
не нужны. Метки с разной методикой не сравниваются (с лабы 2 методика
|
||
включает и хранилища: design change `bench-postgres`, решение 8). Правило
|
||
«эффект или шум» — design change `perf-bottleneck-fix`, решение 7.
|
||
"""
|
||
|
||
import argparse
|
||
import csv
|
||
import json
|
||
import re
|
||
import statistics
|
||
import sys
|
||
from dataclasses import dataclass
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
import scaling
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
BENCH_DIR = ROOT / "evidence" / "bench"
|
||
OUT_DIR = ROOT / "evidence" / "compare"
|
||
SCENARIOS = ("read", "write")
|
||
# ячейка матрицы: сценарий, размер истории, число клиентов
|
||
type CellKey = tuple[str, int, int]
|
||
|
||
|
||
class CompareError(Exception):
|
||
"""Метки нельзя сравнить: сообщение для человека."""
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Label:
|
||
name: str
|
||
meta: dict[str, Any]
|
||
runs: list[dict[str, str]]
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Stat:
|
||
"""Повторы одной ячейки: RPS, CPU на запрос, медианы задержек."""
|
||
|
||
rps: list[float]
|
||
cpu_us: float
|
||
p50: float
|
||
p95: float
|
||
p99: float
|
||
|
||
@property
|
||
def median(self) -> float:
|
||
return statistics.median(self.rps)
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Row:
|
||
key: CellKey
|
||
before: Stat
|
||
after: Stat
|
||
|
||
@property
|
||
def delta(self) -> float:
|
||
"""Изменение медианы RPS, %."""
|
||
return (self.after.median / self.before.median - 1) * 100
|
||
|
||
@property
|
||
def overlap(self) -> bool:
|
||
"""Пересекаются ли разбросы min–max повторов двух меток."""
|
||
return min(self.before.rps) <= max(self.after.rps) and min(
|
||
self.after.rps,
|
||
) <= max(self.before.rps)
|
||
|
||
|
||
def human(n: int) -> str:
|
||
if n >= 1_000_000 and n % 1_000_000 == 0:
|
||
return f"{n // 1_000_000}M"
|
||
if n >= 1000 and n % 1000 == 0:
|
||
return f"{n // 1000}k"
|
||
return str(n)
|
||
|
||
|
||
def load(name: str) -> Label:
|
||
if not re.fullmatch(r"[A-Za-z0-9._-]+", name):
|
||
raise CompareError(f"bad label {name!r}: use [A-Za-z0-9._-]")
|
||
directory = BENCH_DIR / name
|
||
for file in ("meta.json", "runs.csv"):
|
||
if not (directory / file).is_file():
|
||
raise CompareError(
|
||
f"{(directory / file).relative_to(ROOT)} not found",
|
||
)
|
||
meta = json.loads((directory / "meta.json").read_text(encoding="utf-8"))
|
||
with (directory / "runs.csv").open(encoding="utf-8", newline="") as file:
|
||
runs = list(csv.DictReader(file))
|
||
return Label(name=name, meta=meta, runs=runs)
|
||
|
||
|
||
def flatten(prefix: str, value: Any, into: dict[str, Any]) -> None:
|
||
"""Вложенные словари паспорта → плоские ключи `a.b.c`."""
|
||
if isinstance(value, dict):
|
||
for key, inner in value.items():
|
||
flatten(f"{prefix}.{key}", inner, into)
|
||
else:
|
||
into[prefix] = value
|
||
|
||
|
||
def is_series(label: Label) -> bool:
|
||
"""Метка серии трека 1 (design change `scaling-bench`, решение 11)."""
|
||
return bool(label.meta.get("profile", {}).get("series"))
|
||
|
||
|
||
def methodology(
|
||
label: Label,
|
||
configs: set[str] | None = None,
|
||
) -> dict[str, Any]:
|
||
"""Параметры, которые у сравнимых меток обязаны совпадать.
|
||
|
||
Профиль, лимиты всех контейнеров стенда, образ генератора, образы и
|
||
настройки PostgreSQL и Valkey, окружение приложения (решение 8 design
|
||
change `bench-postgres`). У Valkey настройки — `maxmemory*` из
|
||
`valkey.conf`: правку конфигурации образ не покажет. У серий трека 1
|
||
имя, серия и состав конфигураций к методике не относятся, лимиты — по
|
||
общим конфигурациям `configs` (решение 11 design change
|
||
`scaling-bench`).
|
||
"""
|
||
meta = label.meta
|
||
stand = meta.get("stand", {})
|
||
flat: dict[str, Any] = {}
|
||
profile = dict(meta.get("profile", {}))
|
||
limits = meta.get("limits", {})
|
||
if configs is not None:
|
||
for key in ("name", "series", "configs"):
|
||
profile.pop(key, None)
|
||
limits = {key: limits[key] for key in configs if key in limits}
|
||
flatten("profile", profile, flat)
|
||
flatten("limits", limits, flat)
|
||
for name, value in (
|
||
("generator.image", meta.get("generator", {}).get("image")),
|
||
("stand.postgres.image", stand.get("postgres", {}).get("image")),
|
||
("stand.valkey.image", stand.get("valkey", {}).get("image")),
|
||
):
|
||
if value is not None:
|
||
flat[name] = value
|
||
flatten(
|
||
"stand.postgres.settings",
|
||
stand.get("postgres", {}).get("settings", {}),
|
||
flat,
|
||
)
|
||
for key, value in stand.get("valkey", {}).items():
|
||
if key.startswith("maxmemory"):
|
||
flat[f"stand.valkey.{key}"] = value
|
||
flatten("stand.app_env", stand.get("app_env", {}), flat)
|
||
return flat
|
||
|
||
|
||
def check_methodology(
|
||
first: Label,
|
||
second: Label,
|
||
configs: set[str] | None = None,
|
||
) -> list[str]:
|
||
"""Отказ при различии; возвращает параметры, записанные в одной метке.
|
||
|
||
`configs` — общие конфигурации серий трека 1; None — матрица."""
|
||
if is_series(first) != is_series(second):
|
||
series = first if is_series(first) else second
|
||
raise CompareError(
|
||
"different methodology: track 1 series "
|
||
f"{series.name} and matrix "
|
||
f"{(second if series is first else first).name}",
|
||
)
|
||
a, b = methodology(first, configs), methodology(second, configs)
|
||
# с change graceful-failover в пути запроса стоит HAProxy, и паспорт
|
||
# пишет число реплик; метка без него снята мимо LB — другая методика
|
||
# (решение 6 design change graceful-failover), а не «параметр
|
||
# записан только в одной метке»
|
||
without_lb = [
|
||
label.name
|
||
for label, flat in ((first, a), (second, b))
|
||
if configs is None and "limits.api_replicas" not in flat
|
||
]
|
||
if len(without_lb) == 1:
|
||
raise CompareError(
|
||
f"label {without_lb[0]} was measured without the load balancer "
|
||
"(before change graceful-failover): different methodology",
|
||
)
|
||
differs = [
|
||
f"{key}: {first.name} = {a[key]!r}, {second.name} = {b[key]!r}"
|
||
for key in sorted(a.keys() & b.keys())
|
||
if a[key] != b[key]
|
||
]
|
||
if differs:
|
||
raise CompareError(
|
||
f"labels {first.name} and {second.name} were measured with "
|
||
"different methodology:\n " + "\n ".join(differs),
|
||
)
|
||
return [
|
||
f"`{key}` записан только в `{(first if key in a else second).name}`: "
|
||
"совпадение не проверено"
|
||
for key in sorted(a.keys() ^ b.keys())
|
||
]
|
||
|
||
|
||
def notes(label: Label) -> list[str]:
|
||
"""Что мешает считать метку чистым замером."""
|
||
meta = label.meta
|
||
found = []
|
||
if meta.get("status") != "complete":
|
||
found.append(f"статус {meta.get('status')}: {meta.get('reason')}")
|
||
if meta.get("git", {}).get("dirty"):
|
||
found.append("незакоммиченные изменения (`dirty: true`)")
|
||
if meta.get("overrides"):
|
||
found.append(f"отладочные переопределения {meta['overrides']}")
|
||
found += [f"хост: {text}" for text in meta.get("host_warnings", [])]
|
||
if meta.get("other_containers"):
|
||
found.append(
|
||
"посторонние контейнеры: " + ", ".join(meta["other_containers"]),
|
||
)
|
||
flagged = [
|
||
run["run"]
|
||
for run in label.runs
|
||
if run.get("flags")
|
||
or run.get("requests_failed", "0") not in ("0", "")
|
||
or run.get("check_failed", "0") not in ("0", "")
|
||
]
|
||
if flagged:
|
||
found.append("прогоны с пометками или ошибками: " + ", ".join(flagged))
|
||
return [f"`{label.name}`: {text}" for text in found]
|
||
|
||
|
||
def cells(label: Label) -> dict[CellKey, Stat]:
|
||
grouped: dict[CellKey, list[dict[str, str]]] = {}
|
||
for run in label.runs:
|
||
if not run["rps"] or float(run["rps"]) <= 0:
|
||
continue
|
||
key = (run["scenario"], int(run["size"]), int(run["concurrency"]))
|
||
grouped.setdefault(key, []).append(run)
|
||
|
||
def median(rows: list[dict[str, str]], column: str) -> float:
|
||
return statistics.median(float(row[column]) for row in rows)
|
||
|
||
return {
|
||
key: Stat(
|
||
rps=[float(row["rps"]) for row in rows],
|
||
cpu_us=statistics.median(
|
||
float(row["app_cpu_cores"]) / float(row["rps"]) * 1e6
|
||
for row in rows
|
||
),
|
||
p50=median(rows, "p50_ms"),
|
||
p95=median(rows, "p95_ms"),
|
||
p99=median(rows, "p99_ms"),
|
||
)
|
||
for key, rows in grouped.items()
|
||
}
|
||
|
||
|
||
def compare(before: Label, after: Label) -> tuple[list[Row], list[str]]:
|
||
"""Строки по общим ячейкам и замечания о ячейках одной метки."""
|
||
first, second = cells(before), cells(after)
|
||
rows = [
|
||
Row(key=key, before=first[key], after=second[key])
|
||
for key in first
|
||
if key in second
|
||
]
|
||
lonely = [
|
||
f"ячейка {key[0]} {human(key[1])} × {key[2]} есть только в "
|
||
f"`{(before if key in first else after).name}`"
|
||
for key in sorted(first.keys() ^ second.keys())
|
||
]
|
||
repeats = [
|
||
f"ячейка {row.key[0]} {human(row.key[1])} × {row.key[2]}: повторов "
|
||
f"{len(row.before.rps)} и {len(row.after.rps)}"
|
||
for row in rows
|
||
if len(row.before.rps) != len(row.after.rps)
|
||
]
|
||
return rows, lonely + repeats
|
||
|
||
|
||
def noise_floor(rows: list[Row]) -> dict[str, Row]:
|
||
"""Ячейка с наибольшим изменением медианы RPS в каждом сценарии."""
|
||
floor: dict[str, Row] = {}
|
||
for row in rows:
|
||
worst = floor.get(row.key[0])
|
||
if worst is None or abs(row.delta) > abs(worst.delta):
|
||
floor[row.key[0]] = row
|
||
return floor
|
||
|
||
|
||
def passport_rows(labels: list[Label]) -> list[str]:
|
||
def field(title: str, value: Any) -> str:
|
||
return (
|
||
f"| {title} | " + " | ".join(value(x.meta) for x in labels) + " |"
|
||
)
|
||
|
||
def host(meta: dict[str, Any]) -> str:
|
||
# занятый swap — не помеха; помеха — выгрузка за прогон (решение 12
|
||
# design change scaling-bench)
|
||
state = meta.get("host_state", {})
|
||
start = state.get("start", {})
|
||
before = start.get("swapouts")
|
||
after = state.get("end", {}).get("swapouts")
|
||
swapped = (
|
||
f"выгрузок в swap за прогон {after - before}"
|
||
if before is not None and after is not None
|
||
else f"swap {start.get('swap_used_mib')} МиБ"
|
||
)
|
||
return f"{swapped}, {start.get('power')}"
|
||
|
||
def versions(meta: dict[str, Any]) -> str:
|
||
found = meta.get("app_image", {}).get("versions", {})
|
||
return ", ".join(f"{name} {ver}" for name, ver in found.items())
|
||
|
||
def machine(meta: dict[str, Any]) -> str:
|
||
found, docker = meta.get("host", {}), meta.get("docker", {})
|
||
cores = (
|
||
f" ({found['performance_cores']} P + "
|
||
f"{found['efficiency_cores']} E)"
|
||
if found.get("performance_cores") is not None
|
||
else ""
|
||
)
|
||
return (
|
||
f"{found.get('machine')}{cores}, ВМ {docker.get('vm_cpus')} vCPU "
|
||
f"/ {docker.get('vm_memory_gib')} GiB, Docker "
|
||
f"{docker.get('server')}"
|
||
)
|
||
|
||
return [
|
||
"| | " + " | ".join(f"`{x.name}`" for x in labels) + " |",
|
||
"|---|" + "---|" * len(labels),
|
||
field("Commit", lambda m: f"`{m.get('git', {}).get('commit')}`"),
|
||
field("Начало прогона", lambda m: str(m.get("started_at"))),
|
||
field("Статус", lambda m: str(m.get("status"))),
|
||
field("Версии в образе", versions),
|
||
field("Машина", machine),
|
||
field("Хост в начале", host),
|
||
]
|
||
|
||
|
||
def scenario_table(
|
||
rows: list[Row],
|
||
floor: dict[str, Row] | None,
|
||
) -> list[str]:
|
||
lines = [
|
||
"| Размер | Клиенты | RPS до | RPS после | Δ RPS | Вывод | "
|
||
"CPU на запрос, мкс | Δ CPU, мкс | p50, мс | p95, мс | p99, мс |",
|
||
"|---|---|---|---|---|---|---|---|---|---|---|",
|
||
]
|
||
for row in rows:
|
||
before, after = row.before, row.after
|
||
if floor is None:
|
||
verdict = (
|
||
"разбросы пересекаются"
|
||
if row.overlap
|
||
else "разбросы не пересекаются"
|
||
)
|
||
elif not row.overlap and abs(row.delta) > abs(floor[row.key[0]].delta):
|
||
verdict = "эффект"
|
||
else:
|
||
verdict = "в пределах шума"
|
||
lines.append(
|
||
f"| {human(row.key[1])} | {row.key[2]} | "
|
||
f"{before.median:.0f} ({min(before.rps):.0f}–"
|
||
f"{max(before.rps):.0f}) | "
|
||
f"{after.median:.0f} ({min(after.rps):.0f}–"
|
||
f"{max(after.rps):.0f}) | "
|
||
f"{row.delta:+.1f}% | {verdict} | "
|
||
f"{before.cpu_us:.0f} → {after.cpu_us:.0f} | "
|
||
f"{after.cpu_us - before.cpu_us:+.0f} | "
|
||
f"{before.p50:.2f} → {after.p50:.2f} | "
|
||
f"{before.p95:.2f} → {after.p95:.2f} | "
|
||
f"{before.p99:.2f} → {after.p99:.2f} |",
|
||
)
|
||
deltas = [row.delta for row in rows]
|
||
lines += [
|
||
"",
|
||
f"Δ RPS по ячейкам: от {min(deltas):+.1f}% до {max(deltas):+.1f}%, "
|
||
f"медиана {statistics.median(deltas):+.1f}%.",
|
||
]
|
||
return lines
|
||
|
||
|
||
def memory_table(before: Label, after: Label) -> list[str]:
|
||
def sizes(label: Label) -> dict[int, dict[str, Any]]:
|
||
return {item["size"]: item for item in label.meta.get("sizes", [])}
|
||
|
||
first, second = sizes(before), sizes(after)
|
||
lines = [
|
||
"| Размер | Байт RSS на сообщение до | после | "
|
||
"RSS после наполнения до, МиБ | после | "
|
||
"Байт в БД на сообщение до | после |",
|
||
"|---|---|---|---|---|---|---|",
|
||
]
|
||
for size in sorted(first.keys() & second.keys()):
|
||
a, b = first[size], second[size]
|
||
lines.append(
|
||
f"| {human(size)} | {a.get('bytes_per_message')} | "
|
||
f"{b.get('bytes_per_message')} | {a.get('rss_after_mib')} | "
|
||
f"{b.get('rss_after_mib')} | {a.get('db_bytes_per_message')} | "
|
||
f"{b.get('db_bytes_per_message')} |",
|
||
)
|
||
return lines
|
||
|
||
|
||
def render(
|
||
before: Label,
|
||
after: Label,
|
||
aa: Label | None,
|
||
command: str,
|
||
) -> str:
|
||
unverified = check_methodology(before, after)
|
||
rows, remarks = compare(before, after)
|
||
if not rows:
|
||
raise CompareError("labels have no common matrix cells")
|
||
labels = [before, after]
|
||
floor = None
|
||
if aa is not None:
|
||
unverified += check_methodology(aa, before)
|
||
aa_rows, aa_remarks = compare(aa, before)
|
||
floor = noise_floor(aa_rows)
|
||
missing = [s for s in {row.key[0] for row in rows} if s not in floor]
|
||
if missing:
|
||
raise CompareError(
|
||
f"label {aa.name} has no cells for {', '.join(missing)}",
|
||
)
|
||
remarks += aa_remarks
|
||
labels.append(aa)
|
||
remarks = (
|
||
unverified + [text for x in labels for text in notes(x)] + remarks
|
||
)
|
||
lines = [
|
||
f"# Сравнение меток: `{before.name}` → `{after.name}`",
|
||
"",
|
||
f"- Команда: `{command}`",
|
||
"- «До» и «после» — медиана повторов ячейки, в скобках min–max. "
|
||
"Δ RPS — отношение медиан минус единица.",
|
||
"- CPU на запрос — `app_cpu_cores / rps`, медиана по повторам; "
|
||
"задержки — медианы по повторам, «до → после».",
|
||
]
|
||
if aa is None:
|
||
lines.append(
|
||
"- Уровень шума не задан (`AA`): вывод говорит только, "
|
||
"пересекаются ли разбросы повторов.",
|
||
)
|
||
else:
|
||
lines += [
|
||
f"- Уровень шума — наибольшее по ячейкам сценария изменение "
|
||
f"медианы RPS между `{aa.name}` и `{before.name}`. Он имеет "
|
||
"смысл, только если код приложения в этих метках одинаков; "
|
||
"это проверяется по git, команда этого не видит.",
|
||
"- «Эффект» — разбросы повторов не пересекаются и изменение "
|
||
"медианы больше уровня шума сценария; иначе «в пределах шума».",
|
||
]
|
||
lines += [
|
||
"",
|
||
"## Метки",
|
||
"",
|
||
*passport_rows(labels),
|
||
"",
|
||
"## Замечания",
|
||
"",
|
||
]
|
||
lines += [f"- {text}" for text in dict.fromkeys(remarks)] or ["Нет."]
|
||
if floor is not None and aa is not None:
|
||
lines += [
|
||
"",
|
||
"## Уровень шума",
|
||
"",
|
||
f"| Сценарий | Наибольшее изменение RPS, `{aa.name}` → "
|
||
f"`{before.name}` | Ячейка |",
|
||
"|---|---|---|",
|
||
]
|
||
lines += [
|
||
f"| {scenario} | {abs(floor[scenario].delta):.1f}% | "
|
||
f"{human(floor[scenario].key[1])} × {floor[scenario].key[2]} |"
|
||
for scenario in SCENARIOS
|
||
if scenario in floor
|
||
]
|
||
for scenario in SCENARIOS:
|
||
selected = [row for row in rows if row.key[0] == scenario]
|
||
if selected:
|
||
lines += [
|
||
"",
|
||
f"## Сценарий `{scenario}`",
|
||
"",
|
||
*scenario_table(selected, floor),
|
||
]
|
||
lines += ["", "## Память", "", *memory_table(before, after)]
|
||
return "\n".join(lines) + "\n"
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class SeriesRow:
|
||
"""Общая конфигурация двух меток серий: R* повторов и числа сводки."""
|
||
|
||
config: str
|
||
before: dict[str, Any]
|
||
after: dict[str, Any]
|
||
|
||
@property
|
||
def delta(self) -> float:
|
||
return (self.after["r_star"] / self.before["r_star"] - 1) * 100
|
||
|
||
@property
|
||
def overlap(self) -> bool:
|
||
a, b = self.before["r_stars"], self.after["r_stars"]
|
||
return min(a) <= max(b) and min(b) <= max(a)
|
||
|
||
|
||
def series_stats(label: Label) -> dict[str, dict[str, Any]]:
|
||
"""Сводка конфигураций серии (`scaling.config_stats`) с R* полных
|
||
ячеек; ячейки с браком генератора в сравнение не входят."""
|
||
directory = BENCH_DIR / label.name
|
||
searches = scaling.read_csv(directory / "searches.csv")
|
||
return {
|
||
c["config"]: c
|
||
for c in scaling.config_stats(label.meta, label.runs, searches)
|
||
}
|
||
|
||
|
||
def series_notes(label: Label, stats: dict[str, dict[str, Any]]) -> list[str]:
|
||
"""Что мешает считать метку серии чистым замером: прочее — как у
|
||
матрицы, но нарушения SLO на ступенях поиска — норма, а не пометка."""
|
||
meta = label.meta
|
||
found = []
|
||
if meta.get("status") != "complete":
|
||
found.append(f"статус {meta.get('status')}: {meta.get('reason')}")
|
||
if meta.get("git", {}).get("dirty"):
|
||
found.append("незакоммиченные изменения (`dirty: true`)")
|
||
if meta.get("overrides"):
|
||
found.append(f"отладочные переопределения {meta['overrides']}")
|
||
found += [f"хост: {text}" for text in meta.get("host_warnings", [])]
|
||
bound = [cell for c in stats.values() for cell in c["generator_bound"]]
|
||
if bound:
|
||
found.append(
|
||
"брак генератора, ячейки не сравниваются: " + ", ".join(bound),
|
||
)
|
||
marked = sorted(
|
||
{
|
||
run["cell"]
|
||
for run in label.runs
|
||
if {"oom", "app_down", "stand_down", "host_swap"}
|
||
& set((run.get("flags") or "").split())
|
||
},
|
||
)
|
||
if marked:
|
||
found.append(
|
||
"ячейки с отказом стенда или выгрузкой: " + ", ".join(marked),
|
||
)
|
||
return [f"`{label.name}`: {text}" for text in found]
|
||
|
||
|
||
def series_noise(aa: Label, before: Label) -> tuple[float, str]:
|
||
"""Шум A/A серий: наибольшее по общим конфигурациям |Δ медианы R*|."""
|
||
first, second = series_stats(aa), series_stats(before)
|
||
common = [
|
||
SeriesRow(config=key, before=first[key], after=second[key])
|
||
for key in first
|
||
if key in second
|
||
and first[key]["r_stars"]
|
||
and second[key]["r_stars"]
|
||
and first[key]["r_star"]
|
||
]
|
||
if not common:
|
||
raise CompareError(
|
||
f"labels {aa.name} and {before.name} have no common configs",
|
||
)
|
||
worst = max(common, key=lambda row: abs(row.delta))
|
||
return abs(worst.delta), worst.config
|
||
|
||
|
||
def render_series(
|
||
before: Label,
|
||
after: Label,
|
||
aa: Label | None,
|
||
command: str,
|
||
change: str = "scaling-bench",
|
||
) -> str:
|
||
"""Сравнение меток серий трека 1 по общим конфигурациям (решение 11
|
||
design change `scaling-bench`); раздел PostgreSQL на R* и первой
|
||
нарушившей ступени — решение 7 change `scaling-improvement`."""
|
||
first, second = series_stats(before), series_stats(after)
|
||
common = [key for key in first if key in second]
|
||
if not common:
|
||
raise CompareError("labels have no common track 1 configs")
|
||
unverified = check_methodology(before, after, set(common))
|
||
labels = [before, after]
|
||
floor = None
|
||
if aa is not None:
|
||
aa_stats = series_stats(aa)
|
||
unverified += check_methodology(
|
||
aa,
|
||
before,
|
||
{key for key in aa_stats if key in first},
|
||
)
|
||
floor = series_noise(aa, before)
|
||
labels.append(aa)
|
||
remarks = list(unverified)
|
||
remarks += series_notes(before, first) + series_notes(after, second)
|
||
if aa is not None:
|
||
remarks += series_notes(aa, series_stats(aa))
|
||
remarks += [
|
||
f"конфигурация {key} есть только в `{label.name}`: не сравнивается"
|
||
for key, label in [
|
||
*((k, before) for k in first if k not in second),
|
||
*((k, after) for k in second if k not in first),
|
||
]
|
||
]
|
||
rows = [
|
||
SeriesRow(config=key, before=first[key], after=second[key])
|
||
for key in common
|
||
if first[key]["r_stars"]
|
||
and second[key]["r_stars"]
|
||
and first[key]["r_star"]
|
||
]
|
||
lines = [
|
||
f"# Сравнение серий: `{before.name}` → `{after.name}`",
|
||
"",
|
||
f"- Команда: `{command}`",
|
||
f"- Спек: `load-benchmark` (сравнение меток), change `{change}`; "
|
||
"даты, commit и хост — таблица «Метки»",
|
||
"- Метки серий трека 1 сравниваются по общим конфигурациям. R* — "
|
||
"медиана повторов, в скобках min–max; Δ R* — отношение медиан "
|
||
"минус единица. Ячейки с браком генератора не входят.",
|
||
"- Задержки — медианы по повторам на фиксированных уровнях, «до → "
|
||
"после»; CPU на запрос — CPU реплик на успешный запрос на втором "
|
||
"фиксированном уровне; CPU PostgreSQL — на ступени R*.",
|
||
]
|
||
if floor is None:
|
||
lines.append(
|
||
"- Уровень шума не задан (`AA`): вывод говорит только, "
|
||
"пересекаются ли разбросы повторов.",
|
||
)
|
||
else:
|
||
lines += [
|
||
f"- Уровень шума — наибольшее по общим конфигурациям изменение "
|
||
f"медианы R* между `{aa.name if aa else ''}` и `{before.name}`: "
|
||
f"{floor[0]:.1f}% ({floor[1]}). Он имеет смысл, только если код "
|
||
"приложения в этих метках одинаков; это проверяется по git.",
|
||
"- «Эффект» — разбросы повторов не пересекаются и изменение "
|
||
"медианы больше уровня шума; иначе «в пределах шума».",
|
||
]
|
||
lines += [
|
||
"",
|
||
"## Метки",
|
||
"",
|
||
*passport_rows(labels),
|
||
"",
|
||
"## Замечания",
|
||
"",
|
||
]
|
||
lines += [f"- {text}" for text in dict.fromkeys(remarks)] or ["Нет."]
|
||
fixed = before.meta["profile"].get("fixed_rps") or []
|
||
second_level = (
|
||
fixed[1] if len(fixed) > 1 else (fixed[0] if fixed else None)
|
||
)
|
||
lines += [
|
||
"",
|
||
"## R* по общим конфигурациям",
|
||
"",
|
||
"| Конфигурация | R* до | R* после | Δ R* | Вывод | "
|
||
+ " | ".join(f"p95 / p99 на {lvl}, мс" for lvl in fixed)
|
||
+ f" | CPU на запрос на {second_level}, мкс | CPU PostgreSQL на R*, "
|
||
"ядер |",
|
||
"|---|---|---|---|---|" + "---|" * len(fixed) + "---|---|",
|
||
]
|
||
for row in rows:
|
||
a, b = row.before, row.after
|
||
if floor is None:
|
||
verdict = (
|
||
"разбросы пересекаются"
|
||
if row.overlap
|
||
else "разбросы не пересекаются"
|
||
)
|
||
elif not row.overlap and abs(row.delta) > floor[0]:
|
||
verdict = "эффект"
|
||
else:
|
||
verdict = "в пределах шума"
|
||
latency = []
|
||
for lvl in fixed:
|
||
fa, fb = a["fixed"].get(lvl) or {}, b["fixed"].get(lvl) or {}
|
||
latency.append(
|
||
f"{scaling.fmt(fa.get('p95'), 1)} → "
|
||
f"{scaling.fmt(fb.get('p95'), 1)} / "
|
||
f"{scaling.fmt(fa.get('p99'), 1)} → "
|
||
f"{scaling.fmt(fb.get('p99'), 1)}",
|
||
)
|
||
us_a = (a["fixed"].get(second_level) or {}).get("app_us")
|
||
us_b = (b["fixed"].get(second_level) or {}).get("app_us")
|
||
lines.append(
|
||
f"| {row.config} | {scaling.spread(a['r_stars'])} | "
|
||
f"{scaling.spread(b['r_stars'])} | {row.delta:+.1f}% | "
|
||
f"{verdict} | "
|
||
+ " | ".join(latency)
|
||
+ f" | {scaling.fmt(us_a, 0)} → {scaling.fmt(us_b, 0)} | "
|
||
f"{scaling.fmt(a['db_cpu_r'], 2)} → {scaling.fmt(b['db_cpu_r'], 2)} |",
|
||
)
|
||
if rows:
|
||
deltas = [row.delta for row in rows]
|
||
lines += [
|
||
"",
|
||
f"Δ R* по конфигурациям: от {min(deltas):+.1f}% до "
|
||
f"{max(deltas):+.1f}%.",
|
||
]
|
||
lines += pg_section(first, second, common)
|
||
return "\n".join(lines) + "\n"
|
||
|
||
|
||
def pg_section(
|
||
first: dict[str, dict[str, Any]],
|
||
second: dict[str, dict[str, Any]],
|
||
common: list[str],
|
||
) -> list[str]:
|
||
"""PostgreSQL на ступени R* и первой нарушившей выше неё: медианы по
|
||
повторам, «до → после»."""
|
||
|
||
def pair(a: Any, b: Any) -> str:
|
||
return f"{scaling.fmt(a)} → {scaling.fmt(b)}"
|
||
|
||
lines = [
|
||
"",
|
||
"## PostgreSQL на R* и первой нарушившей ступени",
|
||
"",
|
||
"Медианы по завершённым ячейкам, «до → после». Уровень R* — медиана "
|
||
"R*; первая нарушившая — ближайшая ступень выше R* ячейки, "
|
||
"нарушившая SLO. CPU PostgreSQL — на успешный запрос; новые сессии "
|
||
"— прирост `pg_stat_database.sessions` за окно; соединения — "
|
||
"наибольшее число соединений с PostgreSQL в окне. Нет значения — "
|
||
"«—».",
|
||
"",
|
||
"| Конфигурация | Ступень | Уровень, запросов/с | CPU PostgreSQL "
|
||
"на запрос, мкс | Новых сессий за окно | Соединений PostgreSQL |",
|
||
"|---|---|---|---|---|---|",
|
||
]
|
||
for key in common:
|
||
a, b = first[key], second[key]
|
||
lines += [
|
||
f"| {key} | R* | {pair(a['r_star'], b['r_star'])} | "
|
||
f"{pair(a['db_us_r'], b['db_us_r'])} | "
|
||
f"{pair(a['sessions_r'], b['sessions_r'])} | "
|
||
f"{pair(a['conn_r'], b['conn_r'])} |",
|
||
f"| {key} | первая нарушившая | "
|
||
f"{pair(a['level_f'], b['level_f'])} | "
|
||
f"{pair(a['db_us_f'], b['db_us_f'])} | "
|
||
f"{pair(a['sessions_f'], b['sessions_f'])} | "
|
||
f"{pair(a['conn_f'], b['conn_f'])} |",
|
||
]
|
||
return lines
|
||
|
||
|
||
def main(argv: list[str]) -> int:
|
||
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||
parser.add_argument("--before", default="")
|
||
parser.add_argument("--after", default="")
|
||
parser.add_argument("--aa", default="")
|
||
# change, к которому относится сравнение серий (строка шапки)
|
||
parser.add_argument("--change", default="scaling-bench")
|
||
args = parser.parse_args(argv)
|
||
if not args.before or not args.after:
|
||
print(
|
||
"both labels are required: "
|
||
"make bench_compare BEFORE=<label> AFTER=<label> [AA=<label>]",
|
||
flush=True,
|
||
)
|
||
return 2
|
||
command = f"make bench_compare BEFORE={args.before} AFTER={args.after}"
|
||
if args.aa:
|
||
command += f" AA={args.aa}"
|
||
if args.change != parser.get_default("change"):
|
||
command += f" CHANGE={args.change}"
|
||
try:
|
||
before, after = load(args.before), load(args.after)
|
||
aa = load(args.aa) if args.aa else None
|
||
if any(is_series(x) for x in (before, after, aa) if x is not None):
|
||
for other in (after, aa):
|
||
if other is not None:
|
||
check_methodology(before, other, set())
|
||
text = render_series(before, after, aa, command, args.change)
|
||
else:
|
||
text = render(before, after, aa, command)
|
||
except CompareError as exc:
|
||
print(f"compare failed: {exc}", flush=True)
|
||
return 1
|
||
out = OUT_DIR / f"{args.before}__{args.after}.md"
|
||
out.parent.mkdir(parents=True, exist_ok=True)
|
||
out.write_text(text, encoding="utf-8")
|
||
print(text, flush=True)
|
||
print(f"saved to {out.relative_to(ROOT)}", flush=True)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main(sys.argv[1:]))
|