- [telemetry] trace_sample_ratio (ParentBased(TraceIdRatioBased), 1 keeps ParentBased(ALWAYS_ON)) and metric_buckets (default|coarse with SLO bounds), export interval <= 30 s; otel.sdk.span.started, span.live dropped; startup records name ratio, buckets and interval - bench: telemetry services on mtusi-bench, TELEMETRY=on switch for uploads and queue, make bench_telemetry[_quick] with off/full/full-aa/head/tail/ metrics/balanced, rare events, lookup from Tempo/Loki/Prometheus, cost sampler, verdicts H1-H8 and B1-B5; collector layers and lean Prometheus in bench/otel with preflight checks - REPORT: telemetry cost hypotheses and criteria before the label Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1168 lines
45 KiB
Python
1168 lines
45 KiB
Python
"""Профиль загрузок: тела, план, разбор и сводка без docker.
|
||
|
||
Оркестрирует прогоны `run.py` (профили `uploads`, `uploads_quick`), здесь
|
||
— чистые функции на stdlib: PNG из шума на `random.Random(seed)`, план
|
||
прогонов кругами, строки k6 о каждой загрузке, строки сэмплера в режиме
|
||
`peak`, строка `runs.csv`, сводка по ячейкам и проверка гипотез H1–H4.
|
||
Методика — design change `upload-memory`, решение 10; правило —
|
||
`.claude/rules/bench.md`, «Профиль загрузок». Проверка —
|
||
`uv run python bench/uploads.py --selftest`.
|
||
"""
|
||
|
||
import hashlib
|
||
import random
|
||
import re
|
||
import statistics
|
||
import struct
|
||
import sys
|
||
import zlib
|
||
from collections.abc import Iterable
|
||
from dataclasses import dataclass, field
|
||
from typing import Any
|
||
|
||
# лимит тела контракта (contracts/README.md, «Вложения (с lab4)»)
|
||
MAX_BODY_BYTES = 10 * 1024 * 1024
|
||
MIB = 2**20
|
||
# ширина PNG из шума: строка 1024 × 3 байта RGB и байт фильтра
|
||
PNG_WIDTH = 1024
|
||
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||
# варианты кода (решение 10): образ commit методики, checkout без лимита,
|
||
# checkout с параметрами по умолчанию
|
||
VARIANTS = ("before", "unlimited", "limited")
|
||
VARIANT_NAMES = {
|
||
"before": "до",
|
||
"unlimited": "без лимита",
|
||
"limited": "с лимитом",
|
||
}
|
||
# коды ответов в runs.csv; 0 — ошибка соединения (ответа нет). Столбец s201 не
|
||
# переименовывается (.claude/rules/bench.md, «Результаты»): в нём код успеха
|
||
# варианта, а какой — называет success_code (design change async-attachments,
|
||
# решение 16). Второй код успеха у того же варианта — s_other
|
||
SUCCESS_FIELD = "s201"
|
||
CODES = (201, 429, 400, 413, 415, 502, 503, 504, 0)
|
||
CODE_FIELDS = [f"s{code}" if code else "s_conn_error" for code in CODES]
|
||
|
||
RUN_FIELDS = [
|
||
"run",
|
||
"variant",
|
||
"size",
|
||
"body_bytes",
|
||
"clients",
|
||
"repeat",
|
||
"order",
|
||
"mem_before_mib",
|
||
"start_peak_mib",
|
||
"peak_mib",
|
||
"peak_source",
|
||
"anon_max_mib",
|
||
"sock_max_mib",
|
||
"oom_kill",
|
||
"exit_code",
|
||
"oom_killed",
|
||
*CODE_FIELDS,
|
||
"s_other",
|
||
"requests",
|
||
"window_s",
|
||
"uploads_per_s",
|
||
"p50_ms",
|
||
"p95_ms",
|
||
"p99_ms",
|
||
"s3_peak_mib",
|
||
"s3_anon_max_mib",
|
||
"lb_peak_mib",
|
||
"lb_sock_max_mib",
|
||
"host_swapouts",
|
||
"flags",
|
||
"success_code",
|
||
]
|
||
|
||
|
||
# ---------------------------------------------------------------- тела
|
||
|
||
|
||
def chunk(kind: bytes, body: bytes) -> bytes:
|
||
"""Чанк PNG с верной CRC."""
|
||
crc = zlib.crc32(kind + body)
|
||
return struct.pack(">I", len(body)) + kind + body + struct.pack(">I", crc)
|
||
|
||
|
||
def png_noise(height: int, seed: int, width: int = PNG_WIDTH) -> bytes:
|
||
"""Настоящий RGB PNG из шума `random.Random(seed)`: строки с фильтром
|
||
0, IDAT — zlib уровня 1 (шум не сжимается, размер ≈ width × height ×
|
||
3). Один `seed` — одни и те же байты."""
|
||
noise = random.Random(seed)
|
||
rows = b"".join(
|
||
b"\x00" + noise.randbytes(width * 3) for _ in range(height)
|
||
)
|
||
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||
return (
|
||
PNG_SIGNATURE
|
||
+ chunk(b"IHDR", ihdr)
|
||
+ chunk(b"IDAT", zlib.compress(rows, 1))
|
||
+ chunk(b"IEND", b"")
|
||
)
|
||
|
||
|
||
def build_bodies(
|
||
sizes: Iterable[tuple[str, int]],
|
||
seed: int,
|
||
) -> dict[str, bytes]:
|
||
"""Тела профиля: имя размера → PNG высоты из профиля; зерно тела —
|
||
`seed` + высота: у полного и быстрого профиля тело одного размера —
|
||
одни и те же байты. Больше лимита контракта — отказ: такое тело
|
||
получало бы 413, а не нагружало память."""
|
||
bodies = {}
|
||
for name, height in sizes:
|
||
data = png_noise(height, seed + height)
|
||
if len(data) > MAX_BODY_BYTES:
|
||
raise ValueError(
|
||
f"body {name}: {len(data)} bytes > {MAX_BODY_BYTES}",
|
||
)
|
||
bodies[name] = data
|
||
return bodies
|
||
|
||
|
||
def body_passport(name: str, height: int, data: bytes) -> dict[str, Any]:
|
||
return {
|
||
"size": name,
|
||
"width": PNG_WIDTH,
|
||
"height": height,
|
||
"bytes": len(data),
|
||
"mib": round(len(data) / MIB, 3),
|
||
"sha256": hashlib.sha256(data).hexdigest(),
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------- план
|
||
|
||
|
||
def plan_runs(
|
||
variants: Iterable[str],
|
||
sizes: Iterable[str],
|
||
clients: Iterable[int],
|
||
repeats: int,
|
||
seed: int,
|
||
) -> list[dict[str, Any]]:
|
||
"""Прогоны кругами: в круге r — перестановка ячеек (вариант × размер
|
||
× клиенты) генератором `Random(seed + r)`; круг не начинается с ячейки,
|
||
на которой кончился прежний (как `scaling.plan_cells`)."""
|
||
cells = [
|
||
(variant, size, count)
|
||
for variant in variants
|
||
for size in sizes
|
||
for count in clients
|
||
]
|
||
plan: list[dict[str, Any]] = []
|
||
previous = None
|
||
for round_no in range(1, repeats + 1):
|
||
order = list(range(len(cells)))
|
||
random.Random(seed + round_no).shuffle(order)
|
||
if len(order) > 1 and order[0] == previous:
|
||
order[0], order[1] = order[1], order[0]
|
||
for index in order:
|
||
variant, size, count = cells[index]
|
||
plan.append(
|
||
{
|
||
"run": f"{variant}-{size}-c{count}-r{round_no}",
|
||
"variant": variant,
|
||
"size": size,
|
||
"clients": count,
|
||
"repeat": round_no,
|
||
"order": len(plan) + 1,
|
||
},
|
||
)
|
||
previous = order[-1]
|
||
return plan
|
||
|
||
|
||
# ------------------------------------------------------------ строки k6
|
||
|
||
|
||
T0_RE = re.compile(r"\bup-t0,(?P<t0>\d+)")
|
||
UPLOAD_RE = re.compile(
|
||
r"\bup,(?P<vu>\d+),(?P<iteration>\d+),(?P<start>\d+),"
|
||
r"(?P<duration>\d+),(?P<status>\d+),(?P<instance>[A-Za-z0-9._-]+)",
|
||
)
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Upload:
|
||
"""Одна загрузка: отправка (мс часов ВМ), длительность, статус."""
|
||
|
||
vu: int
|
||
start_ms: int
|
||
duration_ms: int
|
||
status: int
|
||
instance: str
|
||
|
||
|
||
def parse_k6(text: str) -> tuple[int | None, list[Upload]]:
|
||
"""Строки `uploads.js`: `up-t0,<мс>` из setup и `up,<vu>,<итерация>,
|
||
<отправка>,<длительность>,<статус>,<X-Instance-Id>` на каждую
|
||
загрузку. Строки консоли k6 обёрнуты в его формат — ищется начало
|
||
`up`."""
|
||
t0 = None
|
||
uploads = []
|
||
for line in text.splitlines():
|
||
if match := T0_RE.search(line):
|
||
t0 = int(match["t0"])
|
||
elif match := UPLOAD_RE.search(line):
|
||
uploads.append(
|
||
Upload(
|
||
vu=int(match["vu"]),
|
||
start_ms=int(match["start"]),
|
||
duration_ms=int(match["duration"]),
|
||
status=int(match["status"]),
|
||
instance=match["instance"],
|
||
),
|
||
)
|
||
return t0, uploads
|
||
|
||
|
||
def percentile(values: list[float], q: float) -> float | None:
|
||
"""Перцентиль с линейной интерполяцией (как p(N) k6)."""
|
||
if not values:
|
||
return None
|
||
ordered = sorted(values)
|
||
pos = (len(ordered) - 1) * q
|
||
low = int(pos)
|
||
high = min(low + 1, len(ordered) - 1)
|
||
return ordered[low] + (ordered[high] - ordered[low]) * (pos - low)
|
||
|
||
|
||
def k6_stats(
|
||
uploads: list[Upload],
|
||
t0: int,
|
||
ramp_s: float,
|
||
window_s: float,
|
||
*,
|
||
success_code: int,
|
||
) -> dict[str, Any]:
|
||
"""Ответы по кодам — за весь прогон (разгон и окно, в том числе после
|
||
гибели реплики); успешных загрузок в секунду и их перцентили — по
|
||
загрузкам, отправленным в окне `[t0 + ramp, t0 + ramp + window)`.
|
||
Успешная — ответ с `success_code` варианта, он считается в `s201`;
|
||
прочий 201 или 202 — в `s_other`."""
|
||
counts = dict.fromkeys(CODE_FIELDS, 0)
|
||
other = 0
|
||
for item in uploads:
|
||
if item.status == success_code:
|
||
counts[SUCCESS_FIELD] += 1
|
||
elif item.status in CODES and item.status != 201:
|
||
key = f"s{item.status}" if item.status else "s_conn_error"
|
||
counts[key] += 1
|
||
else:
|
||
other += 1
|
||
w0 = t0 + ramp_s * 1000
|
||
w1 = w0 + window_s * 1000
|
||
ok = [
|
||
item.duration_ms
|
||
for item in uploads
|
||
if item.status == success_code and w0 <= item.start_ms < w1
|
||
]
|
||
|
||
def ms(value: float | None) -> float | None:
|
||
return None if value is None else round(value, 1)
|
||
|
||
return {
|
||
**counts,
|
||
"success_code": success_code,
|
||
"s_other": other,
|
||
"requests": len(uploads),
|
||
"window_s": window_s,
|
||
"uploads_per_s": round(len(ok) / window_s, 2),
|
||
"p50_ms": ms(percentile(ok, 0.5)),
|
||
"p95_ms": ms(percentile(ok, 0.95)),
|
||
"p99_ms": ms(percentile(ok, 0.99)),
|
||
}
|
||
|
||
|
||
# -------------------------------------------------------- строки сэмплера
|
||
|
||
|
||
@dataclass
|
||
class Peak:
|
||
"""Память одного контейнера за окно по строкам сэмплера `peak`."""
|
||
|
||
start_peak: int | None = None
|
||
reset: bool = False
|
||
peak: int | None = None
|
||
first_current: int | None = None
|
||
max_current: int = 0
|
||
max_anon: int = 0
|
||
max_sock: int = 0
|
||
oom_kill_start: int | None = None
|
||
oom_kill_end: int | None = None
|
||
samples: int = 0
|
||
missing: int = 0
|
||
|
||
@property
|
||
def oom_kills(self) -> int:
|
||
if self.oom_kill_start is None or self.oom_kill_end is None:
|
||
return 0
|
||
return self.oom_kill_end - self.oom_kill_start
|
||
|
||
@property
|
||
def window_peak(self) -> int | None:
|
||
"""Пик окна: значение `memory.peak` через свой дескриптор после
|
||
сброса; без сброса или без чтения (контейнер погиб) — наибольшая
|
||
выборка `memory.current`."""
|
||
if self.reset and self.peak is not None:
|
||
return max(self.peak, self.max_current)
|
||
return self.max_current or None
|
||
|
||
@property
|
||
def source(self) -> str:
|
||
return "reset" if self.reset and self.peak is not None else "sampled"
|
||
|
||
|
||
@dataclass
|
||
class PeakSamples:
|
||
roles: dict[str, Peak] = field(default_factory=dict)
|
||
ended: bool = False
|
||
|
||
|
||
def parse_peak(text: str) -> PeakSamples:
|
||
"""Строки сэмплера в режиме `peak` (`bench/sampler.sh`):
|
||
`start <роль> <байт>|missing`, `reset <роль> ok|failed`,
|
||
`pk <нс> <роль> <id12> <current> <anon> <sock> <oom_kill>` или
|
||
`pk <нс> <роль> <id12> missing`, `peak <роль> <байт>|missing`,
|
||
`end <нс>`."""
|
||
result = PeakSamples()
|
||
|
||
def role(name: str) -> Peak:
|
||
return result.roles.setdefault(name, Peak())
|
||
|
||
for line in text.splitlines():
|
||
parts = line.split()
|
||
if not parts:
|
||
continue
|
||
kind = parts[0]
|
||
if kind == "start" and len(parts) == 3 and parts[2].isdigit():
|
||
role(parts[1]).start_peak = int(parts[2])
|
||
elif kind == "reset" and len(parts) >= 3:
|
||
role(parts[1]).reset = parts[2] == "ok"
|
||
elif kind == "pk" and len(parts) == 8:
|
||
item = role(parts[2])
|
||
current, anon, sock, oom = (int(v) for v in parts[4:8])
|
||
item.samples += 1
|
||
if item.first_current is None:
|
||
item.first_current = current
|
||
item.max_current = max(item.max_current, current)
|
||
item.max_anon = max(item.max_anon, anon)
|
||
item.max_sock = max(item.max_sock, sock)
|
||
if item.oom_kill_start is None:
|
||
item.oom_kill_start = oom
|
||
item.oom_kill_end = oom
|
||
elif kind == "pk" and len(parts) == 5 and parts[4] == "missing":
|
||
role(parts[2]).missing += 1
|
||
elif kind == "peak" and len(parts) == 3 and parts[2].isdigit():
|
||
role(parts[1]).peak = int(parts[2])
|
||
elif kind == "end":
|
||
result.ended = True
|
||
return result
|
||
|
||
|
||
def mib(value: int | None) -> float | None:
|
||
return None if value is None else round(value / MIB, 1)
|
||
|
||
|
||
def run_row(
|
||
run: dict[str, Any],
|
||
body_bytes: int,
|
||
peaks: PeakSamples,
|
||
stats: dict[str, Any],
|
||
state: dict[str, Any],
|
||
swapouts: int | None,
|
||
) -> dict[str, Any]:
|
||
"""Строка `runs.csv` прогона. Пометки: `oom` — реплику завершило ядро
|
||
из-за памяти (`OOMKilled` контейнера или `oom_kill` cgroup),
|
||
`host_swap` — хост выгружал страницы в swap во время прогона,
|
||
`peak_sampled` — пик окна по выборкам, а не по сброшенному
|
||
`memory.peak`, `s3_down` — S3 не дожил до конца прогона."""
|
||
app = peaks.roles.get("api", Peak())
|
||
s3 = peaks.roles.get("s3", Peak())
|
||
lb = peaks.roles.get("haproxy", Peak())
|
||
oom = bool(state.get("oom_killed")) or app.oom_kills > 0
|
||
flags = []
|
||
if oom:
|
||
flags.append("oom")
|
||
if swapouts:
|
||
flags.append("host_swap")
|
||
if app.source == "sampled":
|
||
flags.append("peak_sampled")
|
||
if state.get("s3_down"):
|
||
flags.append("s3_down")
|
||
return {
|
||
**{key: run[key] for key in ("run", "variant", "size", "clients")},
|
||
"repeat": run["repeat"],
|
||
"order": run["order"],
|
||
"body_bytes": body_bytes,
|
||
"mem_before_mib": mib(app.first_current),
|
||
"start_peak_mib": mib(app.start_peak),
|
||
"peak_mib": mib(app.window_peak),
|
||
"peak_source": app.source,
|
||
"anon_max_mib": mib(app.max_anon),
|
||
"sock_max_mib": mib(app.max_sock),
|
||
"oom_kill": app.oom_kills,
|
||
"exit_code": state.get("exit_code"),
|
||
"oom_killed": bool(state.get("oom_killed")),
|
||
**stats,
|
||
"s3_peak_mib": mib(s3.window_peak),
|
||
"s3_anon_max_mib": mib(s3.max_anon),
|
||
"lb_peak_mib": mib(lb.window_peak),
|
||
"lb_sock_max_mib": mib(lb.max_sock),
|
||
"host_swapouts": swapouts,
|
||
"flags": " ".join(flags),
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------- сводка
|
||
|
||
|
||
def num(value: Any) -> float | None:
|
||
if value is None or value == "":
|
||
return None
|
||
return float(value)
|
||
|
||
|
||
def spread(values: Iterable[float | None], digits: int = 1) -> str:
|
||
"""Медиана и min–max повторов; один повтор — значение."""
|
||
present = [v for v in values if v is not None]
|
||
if not present:
|
||
return "—"
|
||
mid = statistics.median(present)
|
||
if len(present) == 1:
|
||
return f"{mid:.{digits}f}"
|
||
return (
|
||
f"{mid:.{digits}f} ({min(present):.{digits}f}–"
|
||
f"{max(present):.{digits}f})"
|
||
)
|
||
|
||
|
||
def median(values: Iterable[float | None]) -> float | None:
|
||
present = [v for v in values if v is not None]
|
||
return statistics.median(present) if present else None
|
||
|
||
|
||
def is_oom(row: dict[str, Any]) -> bool:
|
||
return "oom" in str(row.get("flags", "")).split()
|
||
|
||
|
||
def errors_5xx(row: dict[str, Any]) -> int:
|
||
return sum(int(num(row.get(f"s{code}")) or 0) for code in (502, 503, 504))
|
||
|
||
|
||
def cells(
|
||
rows: list[dict[str, Any]],
|
||
) -> dict[tuple[str, str, int], list[dict[str, Any]]]:
|
||
grouped: dict[tuple[str, str, int], list[dict[str, Any]]] = {}
|
||
for row in rows:
|
||
key = (row["variant"], row["size"], int(row["clients"]))
|
||
grouped.setdefault(key, []).append(row)
|
||
return grouped
|
||
|
||
|
||
def per_client_bodies(row: dict[str, Any]) -> float | None:
|
||
"""Рост пика окна над памятью до окна на клиента, в телах."""
|
||
peak, before = num(row.get("peak_mib")), num(row.get("mem_before_mib"))
|
||
body = num(row.get("body_bytes"))
|
||
clients = int(row["clients"])
|
||
if peak is None or before is None or not body or not clients:
|
||
return None
|
||
return (peak - before) * MIB / body / clients
|
||
|
||
|
||
def growth_per_client(
|
||
base: float | None,
|
||
value: float | None,
|
||
clients: int,
|
||
) -> float | None:
|
||
"""Рост медианы ячейки над базовой ячейкой на клиента, MiB."""
|
||
if base is None or value is None or clients <= 0:
|
||
return None
|
||
return (value - base) / clients
|
||
|
||
|
||
def cell_median(
|
||
grouped: dict[tuple[str, str, int], list[dict[str, Any]]],
|
||
key: tuple[str, str, int],
|
||
column: str,
|
||
) -> float | None:
|
||
return median(num(r.get(column)) for r in grouped.get(key, []))
|
||
|
||
|
||
def hypotheses(
|
||
rows: list[dict[str, Any]],
|
||
*,
|
||
memory_limit_mib: float,
|
||
big: str,
|
||
) -> list[dict[str, str]]:
|
||
"""Проверка гипотез H1–H4 числами ячеек (design change
|
||
`upload-memory`, решение 10). Итог — «да», «нет» или «нет данных»;
|
||
вывода по гипотезе сводка не делает."""
|
||
grouped = cells(rows)
|
||
|
||
def group(variant: str, size: str, clients: int) -> list[dict[str, Any]]:
|
||
return grouped.get((variant, size, clients), [])
|
||
|
||
def peak(variant: str, clients: int) -> float | None:
|
||
return median(num(r["peak_mib"]) for r in group(variant, big, clients))
|
||
|
||
out = []
|
||
# H1: с лимитом пик ≤ половины лимита, рост сверх C=10 ≤ 1 MiB на
|
||
# клиента, OOM и 5xx нет, лишние — 429. Всё — по ячейкам тела big и
|
||
# C = 10, 20, 40, как в тексте гипотезы (метка baseline считала OOM,
|
||
# 5xx и 429 по всем размерам и C = 1)
|
||
levels = [c for c in (10, 20, 40) if group("limited", big, c)]
|
||
if levels:
|
||
limited = [r for c in levels for r in group("limited", big, c)]
|
||
peaks = {c: peak("limited", c) for c in levels}
|
||
base = peaks.get(10)
|
||
growth = {
|
||
c: growth_per_client(base, peaks[c], c - 10)
|
||
for c in levels
|
||
if c > 10
|
||
}
|
||
growth_ok = all(v is not None and v <= 1 for v in growth.values())
|
||
half_ok = all(
|
||
v is not None and v <= memory_limit_mib / 2 for v in peaks.values()
|
||
)
|
||
oom = sum(is_oom(r) for r in limited)
|
||
fives = sum(errors_5xx(r) for r in limited)
|
||
busy = sum(int(num(r.get("s429")) or 0) for r in limited)
|
||
verdict = half_ok and growth_ok and not oom and not fives
|
||
out.append(
|
||
{
|
||
"id": "H1",
|
||
"text": "«с лимитом»: пик при 10 MiB и C = 10, 20, 40 ≤ "
|
||
"половины лимита; сверх C = 10 — ≤ 1 MiB на клиента; OOM "
|
||
"и 5xx нет, лишние — 429",
|
||
"numbers": "пик, MiB: "
|
||
+ ", ".join(f"C={c} {fmt(peaks[c])}" for c in levels)
|
||
+ f" (половина лимита {memory_limit_mib / 2:g}); сверх "
|
||
"C=10, MiB на клиента: "
|
||
+ (
|
||
", ".join(f"C={c} {fmt(v, 2)}" for c, v in growth.items())
|
||
or "—"
|
||
)
|
||
+ f"; OOM {oom}, 5xx {fives}, 429 {busy}",
|
||
"result": "да" if verdict else "нет",
|
||
},
|
||
)
|
||
else:
|
||
out.append(no_data("H1"))
|
||
# H2: без лимита рост ~1,2–1,3 тела на клиента, 40 × 10 MiB — OOM; «до»
|
||
# — ~2,1 тела на клиента и OOM уже при 20 × 10 MiB
|
||
parts = []
|
||
for variant in ("unlimited", "before"):
|
||
for clients in (10, 20, 40):
|
||
items = group(variant, big, clients)
|
||
if not items:
|
||
continue
|
||
ooms = sum(is_oom(r) for r in items)
|
||
slope = median(
|
||
per_client_bodies(r) for r in items if not is_oom(r)
|
||
)
|
||
parts.append(
|
||
f"{VARIANT_NAMES[variant]} C={clients}: "
|
||
f"{fmt(slope, 2)} тела/клиента, OOM {ooms}/{len(items)}",
|
||
)
|
||
if parts:
|
||
unl40 = group("unlimited", big, 40)
|
||
bef20 = group("before", big, 20)
|
||
slope10 = median(
|
||
per_client_bodies(r)
|
||
for r in group("unlimited", big, 10)
|
||
if not is_oom(r)
|
||
)
|
||
checks = [
|
||
slope10 is not None and slope10 <= 1.5,
|
||
bool(unl40) and all(is_oom(r) for r in unl40),
|
||
]
|
||
if bef20:
|
||
checks.append(all(is_oom(r) for r in bef20))
|
||
out.append(
|
||
{
|
||
"id": "H2",
|
||
"text": "«без лимита»: пик растёт на ~1,2–1,3 тела на "
|
||
"клиента, 40 × 10 MiB — OOM; «до» — ~2,1 тела и OOM при "
|
||
"20 × 10 MiB",
|
||
"numbers": "; ".join(parts),
|
||
"result": "да" if all(checks) else "нет",
|
||
},
|
||
)
|
||
else:
|
||
out.append(no_data("H2"))
|
||
# H3: загрузок/с при C ≥ 10 у «с лимитом» ≥ 90 % «без лимита», пока тот
|
||
# жив
|
||
ratios = []
|
||
for size in sorted({r["size"] for r in rows}):
|
||
for clients in (10, 20, 40):
|
||
lim = group("limited", size, clients)
|
||
unl = group("unlimited", size, clients)
|
||
if not lim or not unl or any(is_oom(r) for r in unl):
|
||
continue
|
||
a = median(num(r["uploads_per_s"]) for r in lim)
|
||
b = median(num(r["uploads_per_s"]) for r in unl)
|
||
if a is not None and b:
|
||
ratios.append((size, clients, a, b, a / b))
|
||
if ratios:
|
||
out.append(
|
||
{
|
||
"id": "H3",
|
||
"text": "успешных загрузок в секунду при C ≥ 10: «с лимитом» ≥ "
|
||
"90 % «без лимита» на тех же C, пока тот жив",
|
||
"numbers": "; ".join(
|
||
f"{s} C={c}: {a:.2f} / {b:.2f} = {ratio:.0%}"
|
||
for s, c, a, b, ratio in ratios
|
||
),
|
||
"result": "да" if all(r[4] >= 0.9 for r in ratios) else "нет",
|
||
},
|
||
)
|
||
else:
|
||
out.append(no_data("H3"))
|
||
# H4: 503 нет ни в одном варианте, пока реплика жива
|
||
alive = [r for r in rows if not is_oom(r)]
|
||
if alive:
|
||
count = sum(int(num(r.get("s503")) or 0) for r in alive)
|
||
out.append(
|
||
{
|
||
"id": "H4",
|
||
"text": "503 из-за срока записи в S3 нет ни в одном варианте, "
|
||
"пока реплика жива",
|
||
"numbers": f"503 в {len(alive)} прогонах без OOM: {count}",
|
||
"result": "да" if count == 0 else "нет",
|
||
},
|
||
)
|
||
else:
|
||
out.append(no_data("H4"))
|
||
return out
|
||
|
||
|
||
def no_data(name: str) -> dict[str, str]:
|
||
return {"id": name, "text": "", "numbers": "", "result": "нет данных"}
|
||
|
||
|
||
def fmt(value: float | None, digits: int = 1) -> str:
|
||
return "—" if value is None else f"{value:.{digits}f}"
|
||
|
||
|
||
def telemetry_line(profile: dict[str, Any]) -> str:
|
||
"""Режим телеметрии метки (design change `track1-telemetry-cost`, решение
|
||
13): у варианта «до» SDK в коде нет — с `on` сравнение смешанное."""
|
||
if profile.get("telemetry") != "on":
|
||
return "Телеметрия стенда выключена (TELEMETRY=off)"
|
||
text = (
|
||
"Телеметрия стенда включена (TELEMETRY=on): SDK реплики с настройками "
|
||
"рабочего стенда, Collector, Prometheus, Loki и Tempo рабочего стенда"
|
||
)
|
||
if "before" in profile.get("uploads_variants", ()):
|
||
text += (
|
||
"; вариант «до» — образ кода без SDK, его сравнение с остальными "
|
||
"вариантами смешанное (с телеметрией против без неё)"
|
||
)
|
||
return text
|
||
|
||
|
||
def render_summary(meta: dict[str, Any], rows: list[dict[str, Any]]) -> str:
|
||
"""`summary.md` метки: паспорт кратко, таблица ячеек (медиана и
|
||
min–max повторов), сценарии спеков и гипотезы."""
|
||
profile = meta["profile"]
|
||
info = meta.get("uploads", {})
|
||
bodies = info.get("bodies", {})
|
||
big = max(bodies, key=lambda k: bodies[k]["bytes"]) if bodies else ""
|
||
limit_mib = (
|
||
round(
|
||
(meta.get("limits", {}).get("api", {}).get("memory") or 0) / MIB,
|
||
)
|
||
or 512
|
||
)
|
||
lines = [
|
||
f"# Профиль загрузок: метка `{meta['label']}`",
|
||
"",
|
||
f"- Статус: **{meta['status']}**"
|
||
+ (f" ({meta['reason']})" if meta.get("reason") else ""),
|
||
f"- Commit: `{meta['git']['commit']}`"
|
||
+ (" + незакоммиченные изменения" if meta["git"]["dirty"] else ""),
|
||
f"- Профиль `{profile['name']}`: варианты "
|
||
+ ", ".join(
|
||
f"«{VARIANT_NAMES[v]}»" for v in profile["uploads_variants"]
|
||
)
|
||
+ (
|
||
f" (образ «до» — commit `{info.get('before_commit')}`)"
|
||
if info.get("before_commit")
|
||
else ""
|
||
)
|
||
+ f"; клиенты {', '.join(map(str, profile['uploads_clients']))}; "
|
||
f"повторов {profile['repeats']}; окно {profile['uploads_window_s']} "
|
||
f"с после {profile['uploads_ramp_s']} с разгона",
|
||
"- Тела: "
|
||
+ ", ".join(
|
||
f"{name} — {item['bytes']} байт ({item['width']} × "
|
||
f"{item['height']}), SHA-256 `{item['sha256'][:16]}…`"
|
||
for name, item in bodies.items()
|
||
),
|
||
f"- Реплика {profile['cpus']} CPU / {profile['memory']} без swap, "
|
||
f"буфер приёма `{meta.get('stand', {}).get('api_tcp_rmem', '—')}`; "
|
||
f"S3 {profile['s3_cpus']} CPU / {profile['s3_memory']}; LB "
|
||
f"{profile['lb_cpus']} CPU / {profile['lb_memory']}. Обработка не "
|
||
"запущена: задания ждут в PostgreSQL",
|
||
"- Код успеха: "
|
||
+ (
|
||
", ".join(
|
||
f"«{VARIANT_NAMES[v]}» — {code}"
|
||
for v, code in info.get("success_codes", {}).items()
|
||
)
|
||
or "—"
|
||
)
|
||
+ " (столбец `s201` `runs.csv` считает код варианта, его называет "
|
||
"`success_code`)",
|
||
"- Пик — `memory.peak` cgroup, сброшенный через свой дескриптор "
|
||
"перед нагрузкой (`peak_source` = reset); без сброса — наибольшая "
|
||
"выборка раз в "
|
||
f"{profile['uploads_sample_interval_s']:g} с (пометка "
|
||
"`peak_sampled`). Память до окна — первая выборка. Ответы по кодам "
|
||
"— за весь прогон, загрузок/с и перцентили — по загрузкам окна. "
|
||
"Значения — медиана (min–max) повторов",
|
||
"- Посторонние контейнеры в VM во время замера: "
|
||
+ (", ".join(meta.get("other_containers") or []) or "нет"),
|
||
"- " + telemetry_line(profile),
|
||
"",
|
||
"## Ячейки",
|
||
"",
|
||
"«Пик старта» — `memory.peak` реплики до сброса (с её запуска: "
|
||
"фиктивный хэш пароля, разогревающая загрузка); пик окна его не "
|
||
"включает.",
|
||
"",
|
||
"| Вариант | Тело | C | Пик старта, MiB | До окна, MiB | Пик, MiB | "
|
||
"anon, MiB | sock, MiB | OOM | Успех | 429 | 5xx | ошибка соединения | "
|
||
"Загрузок/с | p50, мс | p95, мс | S3 пик, MiB | S3 anon, MiB | "
|
||
"LB пик, MiB | Пометки |",
|
||
"|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|"
|
||
"---|---|---|---|",
|
||
]
|
||
grouped = cells(rows)
|
||
order = {v: i for i, v in enumerate(VARIANTS)}
|
||
for (variant, size, clients), items in sorted(
|
||
grouped.items(),
|
||
key=lambda kv: (order.get(kv[0][0], 9), kv[0][1], kv[0][2]),
|
||
):
|
||
flags = sorted({f for r in items for f in str(r["flags"]).split()})
|
||
|
||
def col(key: str, digits: int = 1, rows: list = items) -> str:
|
||
return spread((num(r.get(key)) for r in rows), digits)
|
||
|
||
fives = [float(errors_5xx(r)) for r in items]
|
||
lines.append(
|
||
f"| {VARIANT_NAMES.get(variant, variant)} | {size} | {clients} | "
|
||
f"{col('start_peak_mib')} | "
|
||
f"{col('mem_before_mib')} | {col('peak_mib')} | "
|
||
f"{col('anon_max_mib')} | {col('sock_max_mib')} | "
|
||
f"{sum(is_oom(r) for r in items)}/{len(items)} | "
|
||
f"{col('s201', 0)} | {col('s429', 0)} | {spread(fives, 0)} | "
|
||
f"{col('s_conn_error', 0)} | {col('uploads_per_s', 2)} | "
|
||
f"{col('p50_ms', 0)} | {col('p95_ms', 0)} | "
|
||
f"{col('s3_peak_mib')} | {col('s3_anon_max_mib')} | "
|
||
f"{col('lb_peak_mib')} | {' '.join(flags) or '—'} |",
|
||
)
|
||
lines.append("")
|
||
lines += scenario_lines(rows, big)
|
||
lines += [
|
||
"## Гипотезы",
|
||
"",
|
||
"Гипотезы сформулированы в лабе 4 (design change `upload-memory`, "
|
||
"`openspec/changes/archive/2026-10-22-upload-memory/design.md`); "
|
||
f"здесь — только их проверка числами ячеек тела {big or '—'}, лимит "
|
||
f"реплики {limit_mib} MiB. Часть H2 про «до» ждёт код без мест "
|
||
"загрузки: если они есть в commit «до» из шапки, её итог о коде до "
|
||
"`upload-memory` ничего не говорит.",
|
||
"",
|
||
"| Гипотеза | Утверждение | Числа | Выполнена |",
|
||
"|---|---|---|---|",
|
||
]
|
||
for item in hypotheses(rows, memory_limit_mib=limit_mib, big=big):
|
||
lines.append(
|
||
f"| {item['id']} | {item['text'] or '—'} | "
|
||
f"{item['numbers'] or '—'} | {item['result']} |",
|
||
)
|
||
lines.append("")
|
||
if meta.get("host_warnings"):
|
||
lines += ["## Предупреждения о хосте", ""]
|
||
lines += [f"- {w}" for w in meta["host_warnings"]]
|
||
lines.append("")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def scenario_lines(rows: list[dict[str, Any]], big: str) -> list[str]:
|
||
"""Сценарии спеков, которые доказывает метка (исключения сверки
|
||
покрытия `student-tests/spec_coverage.py`)."""
|
||
grouped = cells(rows)
|
||
lines = ["## Сценарии спеков", ""]
|
||
parts = []
|
||
for variant in ("unlimited", "before"):
|
||
items = grouped.get((variant, big, 10), [])
|
||
slope = median(per_client_bodies(r) for r in items if not is_oom(r))
|
||
if items:
|
||
parts.append(
|
||
f"«{VARIANT_NAMES[variant]}» — {fmt(slope, 2)} тела на "
|
||
"загрузку",
|
||
)
|
||
if parts:
|
||
lines.append(
|
||
"- `attachments`, «Одна копия тела при записи в S3» (C = 10, "
|
||
f"{big}): рост пика над памятью до окна — "
|
||
+ "; ".join(parts)
|
||
+ " (порог «без лимита» — 1,5 тела; «до» — справочно: что у кода "
|
||
"до `upload-memory` больше, показано в отчёте лабы 4).",
|
||
)
|
||
lim = [grouped.get(("limited", big, c), []) for c in (10, 20, 40)]
|
||
if any(lim):
|
||
flat = [r for items in lim for r in items]
|
||
base = cell_median(grouped, ("limited", big, 10), "peak_mib")
|
||
over = [
|
||
f"C={c} "
|
||
+ fmt(
|
||
growth_per_client(
|
||
base,
|
||
cell_median(grouped, ("limited", big, c), "peak_mib"),
|
||
c - 10,
|
||
),
|
||
2,
|
||
)
|
||
for c, items in zip((20, 40), lim[1:], strict=True)
|
||
if items
|
||
]
|
||
lines.append(
|
||
"- `attachments`, «Память не растёт с числом загрузок» («с "
|
||
f"лимитом», {big}): пик реплики "
|
||
+ ", ".join(
|
||
f"C={c} {fmt(median(num(r['peak_mib']) for r in items))}"
|
||
for c, items in zip((10, 20, 40), lim, strict=True)
|
||
if items
|
||
)
|
||
+ (
|
||
" MiB (сверх C=10, MiB на клиента: " + ", ".join(over) + ")"
|
||
if over
|
||
else " MiB"
|
||
)
|
||
+ ", sock "
|
||
+ ", ".join(
|
||
f"C={c} {fmt(median(num(r['sock_max_mib']) for r in items))}"
|
||
for c, items in zip((10, 20, 40), lim, strict=True)
|
||
if items
|
||
)
|
||
+ " MiB, LB "
|
||
+ ", ".join(
|
||
f"C={c} {fmt(median(num(r['lb_peak_mib']) for r in items))}"
|
||
for c, items in zip((10, 20, 40), lim, strict=True)
|
||
if items
|
||
)
|
||
+ f" MiB; OOM {sum(is_oom(r) for r in flat)}, 5xx "
|
||
f"{sum(errors_5xx(r) for r in flat)}, 429 "
|
||
f"{sum(int(num(r.get('s429')) or 0) for r in flat)}.",
|
||
)
|
||
lines.append(buffers_line(grouped, big))
|
||
lines.append("")
|
||
return lines
|
||
|
||
|
||
def buffers_line(
|
||
grouped: dict[tuple[str, str, int], list[dict[str, Any]]],
|
||
big: str,
|
||
) -> str:
|
||
"""`load-balancing`, «Буферы соединений ограничены»: рост медианы пика
|
||
LB и наибольшего `sock` реплики «с лимитом» от C = 1 до C = 40 на
|
||
клиента; выполнен, если их сумма ≤ 1 MiB и при C = 40 нет OOM.
|
||
Сумма — строже прочтения «каждый ≤ 1 MiB» (design, «Уточнения apply»,
|
||
п. 13)."""
|
||
one, top = ("limited", big, 1), ("limited", big, 40)
|
||
name = (
|
||
"- `load-balancing`, «Буферы соединений ограничены» («с лимитом», "
|
||
f"{big}, C = 1 → 40): "
|
||
)
|
||
if not grouped.get(one) or not grouped.get(top):
|
||
return name + "нет данных (нужны ячейки C = 1 и C = 40)."
|
||
parts, total = [], 0.0
|
||
for column, label in (
|
||
("lb_peak_mib", "пик LB"),
|
||
("sock_max_mib", "sock"),
|
||
):
|
||
a = cell_median(grouped, one, column)
|
||
b = cell_median(grouped, top, column)
|
||
slope = growth_per_client(a, b, 39)
|
||
if slope is None:
|
||
return name + f"нет данных ({label})."
|
||
total += slope
|
||
parts.append(
|
||
f"{label} ({fmt(b)} − {fmt(a)}) / 39 = {fmt(slope, 2)} MiB на "
|
||
"клиента",
|
||
)
|
||
ooms = sum(is_oom(r) for r in grouped[top])
|
||
verdict = "да" if total <= 1 and not ooms else "нет"
|
||
return (
|
||
name
|
||
+ "; ".join(parts)
|
||
+ f"; сумма {fmt(total, 2)} (порог 1 MiB на клиента), OOM при "
|
||
f"C = 40 {ooms}/{len(grouped[top])}; выполнен — {verdict}."
|
||
)
|
||
|
||
|
||
# --------------------------------------------------------------- selftest
|
||
|
||
|
||
def selftest() -> int:
|
||
failures: list[str] = []
|
||
|
||
def expect(name: str, got: Any, want: Any) -> None:
|
||
if got != want:
|
||
failures.append(f"{name}: got {got!r}, want {want!r}")
|
||
|
||
sizes = (("1MiB", 341), ("10MiB", 3409))
|
||
first = build_bodies(sizes, 7)
|
||
again = build_bodies(sizes, 7)
|
||
expect("bodies deterministic", first == again, True)
|
||
expect("bodies differ by seed", build_bodies(sizes, 8) == first, False)
|
||
for name, data in first.items():
|
||
expect(f"{name} <= limit", len(data) <= MAX_BODY_BYTES, True)
|
||
expect(f"{name} is PNG", data[:8], PNG_SIGNATURE)
|
||
expect("1MiB size", 1_000_000 < len(first["1MiB"]) < 1_100_000, True)
|
||
expect(
|
||
"10MiB size",
|
||
10_400_000 < len(first["10MiB"]) <= MAX_BODY_BYTES,
|
||
True,
|
||
)
|
||
try:
|
||
build_bodies((("big", 3500),), 1)
|
||
failures.append("body over the limit accepted")
|
||
except ValueError:
|
||
pass
|
||
|
||
plan = plan_runs(("unlimited", "limited"), ("10MiB",), (1, 10, 40), 3, 5)
|
||
expect("plan length", len(plan), 18)
|
||
expect("plan unique", len({p["run"] for p in plan}), 18)
|
||
for r in (1, 2):
|
||
last = [p for p in plan if p["repeat"] == r][-1]
|
||
head = [p for p in plan if p["repeat"] == r + 1][0]
|
||
expect(
|
||
f"round {r + 1} head",
|
||
(head["variant"], head["clients"])
|
||
!= (last["variant"], last["clients"]),
|
||
True,
|
||
)
|
||
expect(
|
||
"plan stable",
|
||
plan
|
||
== plan_runs(
|
||
("unlimited", "limited"),
|
||
("10MiB",),
|
||
(1, 10, 40),
|
||
3,
|
||
5,
|
||
),
|
||
True,
|
||
)
|
||
|
||
console = "\n".join(
|
||
[
|
||
'time="…" level=info msg="up-t0,1000" source=console',
|
||
"up,1,0,1100,90,201,abc",
|
||
"up,2,0,4100,80,201,abc",
|
||
"up,2,1,4300,5,429,abc",
|
||
"up,3,0,24100,10,201,abc",
|
||
"up,3,1,5000,0,0,-",
|
||
"up,3,2,5100,12,503,abc",
|
||
"garbage",
|
||
],
|
||
)
|
||
t0, ups = parse_k6(console)
|
||
expect("t0", t0, 1000)
|
||
expect("uploads", len(ups), 6)
|
||
stats = k6_stats(ups, t0 or 0, 3, 20, success_code=201)
|
||
expect("201", stats["s201"], 3)
|
||
expect("success code", stats["success_code"], 201)
|
||
expect("429", stats["s429"], 1)
|
||
expect("conn", stats["s_conn_error"], 1)
|
||
expect("503", stats["s503"], 1)
|
||
# окно [4000, 24000): одна 201
|
||
expect("uploads/s", stats["uploads_per_s"], 0.05)
|
||
expect("p95", stats["p95_ms"], 80.0)
|
||
expect("percentile", percentile([1, 2, 3, 4], 0.5), 2.5)
|
||
# лаба 5: код успеха варианта — 202, столбец тот же; чужой код успеха —
|
||
# s_other, и в окно не идёт
|
||
_, async_ups = parse_k6(console.replace(",201,", ",202,"))
|
||
accepted = k6_stats(async_ups, t0 or 0, 3, 20, success_code=202)
|
||
expect("202 in s201", accepted["s201"], 3)
|
||
expect("success code 202", accepted["success_code"], 202)
|
||
expect("202 p95", accepted["p95_ms"], 80.0)
|
||
expect("202 other", accepted["s_other"], 0)
|
||
wrong = k6_stats(ups, t0 or 0, 3, 20, success_code=202)
|
||
expect("201 is not success of 202", wrong["s201"], 0)
|
||
expect("201 in s_other", wrong["s_other"], 3)
|
||
expect("no window uploads", wrong["uploads_per_s"], 0.0)
|
||
expect("no percentiles", wrong["p95_ms"], None)
|
||
swapped = k6_stats(async_ups, t0 or 0, 3, 20, success_code=201)
|
||
expect("202 is not success of 201", swapped["s201"], 0)
|
||
expect("202 in s_other", swapped["s_other"], 3)
|
||
expect("success_code column last", RUN_FIELDS[-1], "success_code")
|
||
expect("s201 column kept", "s201" in RUN_FIELDS, True)
|
||
|
||
sampler = "\n".join(
|
||
[
|
||
"start api 160000000",
|
||
"start s3 50000000",
|
||
"reset api ok",
|
||
"reset s3 failed",
|
||
"pk 1 api abc 100000000 90000000 1000000 0",
|
||
"pk 2 api abc 150000000 140000000 4000000 0",
|
||
"pk 3 api abc missing",
|
||
"pk 1 s3 def 40000000 30000000 0 0",
|
||
"pk 2 s3 def 60000000 35000000 0 0",
|
||
"peak api 152000000",
|
||
"peak s3 70000000",
|
||
"end 4",
|
||
],
|
||
)
|
||
parsed = parse_peak(sampler)
|
||
api = parsed.roles["api"]
|
||
expect("ended", parsed.ended, True)
|
||
expect("api window peak", api.window_peak, 152000000)
|
||
expect("api source", api.source, "reset")
|
||
expect("api first", api.first_current, 100000000)
|
||
expect("api missing", api.missing, 1)
|
||
expect("s3 sampled", parsed.roles["s3"].window_peak, 60000000)
|
||
expect("s3 source", parsed.roles["s3"].source, "sampled")
|
||
oom = parse_peak("pk 1 api a 1 1 1 0\npk 2 api a 2 2 2 1\n")
|
||
expect("oom kills", oom.roles["api"].oom_kills, 1)
|
||
|
||
run = plan[0]
|
||
row = run_row(run, 10_000_000, parsed, stats, {"oom_killed": True}, 3)
|
||
expect("row flags", row["flags"], "oom host_swap")
|
||
expect("row fields", set(RUN_FIELDS) >= set(row), True)
|
||
expect("row peak", row["peak_mib"], 145.0)
|
||
expect("row success code", row["success_code"], 201)
|
||
downed = run_row(run, 1, parsed, stats, {"s3_down": True}, 0)
|
||
expect("row s3_down", downed["flags"], "s3_down")
|
||
|
||
def synth(variant: str, clients: int, peak: float, **extra: Any) -> dict:
|
||
base = {
|
||
"run": f"{variant}-{clients}",
|
||
"variant": variant,
|
||
"size": "10MiB",
|
||
"clients": clients,
|
||
"body_bytes": 10 * MIB,
|
||
"mem_before_mib": 100.0,
|
||
"peak_mib": peak,
|
||
"uploads_per_s": 8.0,
|
||
"s201": 100,
|
||
"s429": 0,
|
||
"s503": 0,
|
||
"flags": "",
|
||
"sock_max_mib": 5,
|
||
"lb_peak_mib": 50,
|
||
}
|
||
return {**base, **extra}
|
||
|
||
rows = [
|
||
synth("limited", 1, 120, s429=7, lb_peak_mib=30, sock_max_mib=4),
|
||
synth("limited", 10, 170),
|
||
synth("limited", 20, 178, s429=5),
|
||
synth("limited", 40, 180, s429=60),
|
||
# другое тело: в H1 не входит ни 429, ни OOM
|
||
synth("limited", 40, 140, size="1MiB", s429=1000, flags="oom"),
|
||
synth("unlimited", 10, 230),
|
||
synth("unlimited", 20, 350),
|
||
synth("unlimited", 40, 512, flags="oom"),
|
||
synth("before", 10, 316),
|
||
synth("before", 20, 512, flags="oom"),
|
||
]
|
||
checked = hypotheses(rows, memory_limit_mib=512, big="10MiB")
|
||
result = {h["id"]: h["result"] for h in checked}
|
||
h1 = checked[0]["numbers"]
|
||
expect("H1 429 of big body, C >= 10", "429 65" in h1, True)
|
||
expect("H1 OOM of big body", "OOM 0," in h1, True)
|
||
expect("H1 growth", "C=20 0.80, C=40 0.33" in h1, True)
|
||
expect("H1", result["H1"], "да")
|
||
expect("H2", result["H2"], "да")
|
||
expect("H3", result["H3"], "да")
|
||
expect("H4", result["H4"], "да")
|
||
worse = rows + [synth("limited", 40, 300, flags="", s503=1)]
|
||
result = {
|
||
h["id"]: h["result"]
|
||
for h in hypotheses(worse, memory_limit_mib=512, big="10MiB")
|
||
}
|
||
expect("H1 worse", result["H1"], "нет")
|
||
expect("H4 worse", result["H4"], "нет")
|
||
meta = {
|
||
"label": "selftest",
|
||
"status": "complete",
|
||
"git": {"commit": "x", "dirty": False},
|
||
"profile": {
|
||
"name": "uploads_quick",
|
||
"uploads_variants": ["unlimited", "limited"],
|
||
"uploads_clients": [1, 10, 40],
|
||
"repeats": 1,
|
||
"uploads_window_s": 20,
|
||
"uploads_ramp_s": 3,
|
||
"uploads_sample_interval_s": 0.2,
|
||
"cpus": "1",
|
||
"memory": "512m",
|
||
"s3_cpus": "1",
|
||
"s3_memory": "512m",
|
||
"lb_cpus": "1",
|
||
"lb_memory": "256m",
|
||
},
|
||
"uploads": {
|
||
"bodies": {"10MiB": body_passport("10MiB", 3409, b"x")},
|
||
"success_codes": {"unlimited": 202, "limited": 202},
|
||
},
|
||
}
|
||
text = render_summary(meta, rows)
|
||
expect("summary has H1", "| H1 |" in text, True)
|
||
expect(
|
||
"summary keeps hypotheses out of report",
|
||
"`REPORT.md`" in text,
|
||
False,
|
||
)
|
||
expect("summary names code", "«с лимитом» — 202" in text, True)
|
||
expect("summary has no broker", "брокер" in text.lower(), False)
|
||
expect("summary jobs wait", "задания ждут в PostgreSQL" in text, True)
|
||
expect("summary has cells", "| с лимитом | 10MiB | 40 |" in text, True)
|
||
expect(
|
||
"replica growth over C=10",
|
||
"(сверх C=10, MiB на клиента: C=20 0.80, C=40 0.33)" in text,
|
||
True,
|
||
)
|
||
expect(
|
||
"buffers verdict",
|
||
"пик LB (50.0 − 30.0) / 39 = 0.51 MiB на клиента; sock (5.0 − 4.0) "
|
||
"/ 39 = 0.03 MiB на клиента; сумма 0.54"
|
||
in text
|
||
and "выполнен — да." in text,
|
||
True,
|
||
)
|
||
wide = rows + [synth("limited", 40, 181, lb_peak_mib=100)]
|
||
expect(
|
||
"buffers over the bound",
|
||
"выполнен — нет." in render_summary(meta, wide),
|
||
True,
|
||
)
|
||
expect(
|
||
"buffers without C=1",
|
||
"нет данных (нужны ячейки C = 1 и C = 40)"
|
||
in "\n".join(scenario_lines(rows[1:], "10MiB")),
|
||
True,
|
||
)
|
||
if failures:
|
||
print("selftest failed:\n " + "\n ".join(failures), flush=True)
|
||
return 1
|
||
print("selftest ok", flush=True)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
if sys.argv[1:] == ["--selftest"]:
|
||
sys.exit(selftest())
|
||
print("usage: uv run python bench/uploads.py --selftest", flush=True)
|
||
sys.exit(2)
|