Files
mtusi2026lab5/bench/resources.py
T
ricoromaandClaude Opus 5.5 04f859282d chore: port lab 4 solution into the lab 5 skeleton
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>
2026-10-31 03:09:12 +03:00

1247 lines
48 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Ресурсы профилей уровня «4» (`failover`, `rollout`) без docker.
Отсчёты сэмплера `bench/sampler.sh` в режиме `scan` (разбор —
`scaling.parse_samples`) → интервалы контейнеров и ВМ → агрегаты окон
фазы или замены, посекундная таблица и разделы `summary.md`. Методика —
design change `profile-resources` (решения 3–7), что стенд обязан делать,
— спек `load-benchmark` («Ресурсы профилей отказа и замены»). Только
stdlib: вызывает `bench/run.py`, самопроверка —
`uv run python bench/resources.py --selftest`.
Все отметки — секунды эпохи на часах ВМ Docker (как в `failover.py`):
строки сэмплера несут наносекунды, разбор переводит их в секунды.
"""
import bisect
import math
import sys
from dataclasses import dataclass
from typing import Any
import scaling
# посекундная таблица и таблица по окнам (решение 7)
SAMPLE_FIELDS = [
"phase",
"window",
"t_s",
"role",
"instance",
"cpu_cores",
"throttled_ms",
"pressure_ms",
"mem_mib",
]
RESOURCE_FIELDS = [
"phase",
"mode",
"window",
"start_s",
"end_s",
"seconds",
"role",
"instance",
"present_s",
"cpu_mean_cores",
"cpu_max_cores",
"cpu_seconds",
"throttled_ratio",
"pressure_share",
"mem_peak_mib",
"ok_rps",
"us_per_ok_request",
"flags",
]
# разгон k6 с первого запроса — вне окон (как before_rows[2:] у
# failover.analyze), с
WARMUP_S = 2.0
# сторож: наибольший промежуток между тиками ВМ в нагрузке, с (решение 2)
GAP_LIMIT_S = 3.0
# установившиеся окна: только в них CPU на успешный запрос (решение 6)
STEADY = {"failover": ("before",), "rollout": ("before", "after")}
# компоненты таблицы по окнам и их порядок (решение 5)
ROLES = {
"failover": (
"api-target",
"api-other",
"api-total",
"postgres",
"haproxy",
"valkey",
"k6",
"sampler",
"vm",
),
"rollout": (
"api-old",
"api-new",
"api-total",
"migrate",
"postgres",
"haproxy",
"valkey",
"k6",
"sampler",
"vm",
),
}
WINDOWS = {
"failover": ("before", "down", "after"),
"rollout": ("before", "prepare", "during", "after"),
}
WARMUP = "warmup"
TOTAL = "api-total"
VM = "vm"
# присутствие короче окна больше чем на столько — пометка partial: CPU
# остановки после последнего отсчёта не виден (разрешение 1 с)
PARTIAL_SLACK_S = 0.5
# /proc/stat — в USER_HZ
JIFFIES_PER_S = 100
WINDOW_TITLES = {
"failover": {
"before": "до действия",
"down": "окно отказа",
"after": "после возврата",
},
"rollout": {
"before": "до",
"prepare": "подготовка",
"during": "замена",
"after": "после",
},
}
ROLE_TITLES = {
"api-target": "цель",
"api-other": "вторая",
"api-old": "старая",
"api-new": "новая",
"api": "реплика",
TOTAL: "API всего",
"migrate": "миграция",
"postgres": "PostgreSQL",
"haproxy": "HAProxy",
"valkey": "Valkey",
"k6": "k6",
"sampler": "сэмплер",
VM: "ВМ",
}
@dataclass(frozen=True)
class Interval:
"""Прирост счётчиков контейнера (или ВМ) за (t0, t1]."""
t0: float
t1: float
cpu_s: float
periods: int
throttled: int
throttled_s: float
pressure_s: float
mem: int
# где внутри (t0, t1] шёл CPU: у интервала, задевающего заморозку, —
# только незамороженная часть; None — весь интервал
busy: tuple[float, float] | None = None
@property
def length(self) -> float:
return self.t1 - self.t0
@property
def span(self) -> tuple[float, float]:
return self.busy or (self.t0, self.t1)
@dataclass
class Series:
"""Компонент: интервалы и память на каждом отсчёте (t, байт)."""
intervals: list[Interval]
memory: list[tuple[float, int]]
seen: bool = True
@dataclass
class Result:
"""Итог анализа фазы: строки `resources.csv` и `samples.csv`,
немаппированные контейнеры (id12)."""
rows: list[dict[str, Any]]
samples: list[dict[str, Any]]
unmapped: list[str]
# ----------------------------------------------------------- интервалы
def ticks_of(samples: Any) -> list[float]:
"""Отметки тиков: строки `vm`, без них — строки `cg`."""
if samples.vm:
return sorted({p[0] / 1e9 for p in samples.vm})
return sorted(
{p[0] / 1e9 for points in samples.cg.values() for p in points},
)
def points_by_id(samples: Any) -> dict[str, list[tuple[int, ...]]]:
"""Отсчёты контейнеров по id12; роль строки сэмплера (`-` в `scan`)
не важна."""
out: dict[str, list[tuple[int, ...]]] = {}
for (_, ident), points in samples.cg.items():
out.setdefault(ident, []).extend(points)
return {ident: sorted(points) for ident, points in out.items()}
def tick_between(ticks: list[float], a: float, b: float) -> bool:
"""Есть тик строго между a и b: контейнер на нём не был виден."""
i = bisect.bisect_right(ticks, a + 1e-6)
return i < len(ticks) and ticks[i] < b - 1e-6
def tick_before(ticks: list[float], t: float) -> float:
i = bisect.bisect_left(ticks, t - 1e-6)
return ticks[i - 1] if i > 0 else t - 1.0
def container_intervals(
points: list[tuple[int, ...]],
starts: list[float],
ticks: list[float],
) -> list[Interval]:
"""Интервалы контейнера по решению 3.
`points` — (нс, usage_usec, nr_periods, nr_throttled, throttled_usec,
memory, psi_usec). Сброс — `usage_usec` уменьшился или после
пропуска тиков между отсчётами есть момент запуска из `starts`: cgroup
новая. Свежий сегмент (сброс или контейнер впервые виден позже
первого тика) — значение отсчёта целиком: CPU от момента запуска (он
же начало интервала), без момента — от предыдущего тика. Первый
отсчёт на первом тике — база. Пропуск тиков без сброса — продолжение.
"""
first_tick = ticks[0] if ticks else None
out: list[Interval] = []
prev: tuple[int, ...] | None = None
for point in points:
t = point[0] / 1e9
if prev is None:
if first_tick is None or t <= first_tick + 1e-6:
prev = point
continue
lower = -math.inf
fresh = True
else:
lower = prev[0] / 1e9
restarted = tick_between(ticks, lower, t) and any(
lower < s <= t for s in starts
)
fresh = point[1] < prev[1] or restarted
if fresh:
moments = [s for s in starts if lower < s <= t]
begin = max(moments) if moments else tick_before(ticks, t)
usage, periods, throttled, thr_usec = point[1:5]
psi = point[6]
else:
assert prev is not None
begin = lower
usage, periods, throttled, thr_usec = (
point[i] - prev[i] for i in range(1, 5)
)
psi = point[6] - prev[6]
prev = point
if t - begin <= 0:
continue
out.append(
Interval(
t0=begin,
t1=t,
cpu_s=usage / 1e6,
periods=periods,
throttled=throttled,
throttled_s=thr_usec / 1e6,
pressure_s=max(0, psi) / 1e6,
mem=point[5],
),
)
return out
def thaw(
intervals: list[Interval],
frozen: list[tuple[float, float]],
) -> list[Interval]:
"""Заморозка (`docker pause` … `unpause`, моменты из событий Docker):
у замороженного CPU не прирастает, поэтому CPU интервала, который
задевает начало заморозки, шёл до него, а задевающего конец — после
(найдено в apply: пропорциональное деление относило часть работы до
`pause` и всплеск после `unpause` к окну отказа)."""
out = []
for interval in intervals:
busy = None
for pause, unpause in frozen:
if interval.t0 < pause < interval.t1 <= unpause:
busy = (interval.t0, pause)
elif pause <= interval.t0 < unpause < interval.t1:
busy = (unpause, interval.t1)
out.append(
interval
if busy is None
else Interval(**{**interval.__dict__, "busy": busy}),
)
return out
def vm_intervals(vm: list[tuple[int, int, int, int]]) -> list[Interval]:
"""Интервалы ВМ: занятые jiffies и PSI CPU между соседними тиками."""
out = []
points = sorted(vm)
for prev, cur in zip(points, points[1:], strict=False):
t0, t1 = prev[0] / 1e9, cur[0] / 1e9
if t1 <= t0:
continue
out.append(
Interval(
t0=t0,
t1=t1,
cpu_s=(cur[1] - prev[1]) / JIFFIES_PER_S,
periods=0,
throttled=0,
throttled_s=0.0,
pressure_s=max(0, cur[3] - prev[3]) / 1e6,
mem=0,
),
)
return out
def max_gap(samples: Any, a: float, b: float) -> float:
"""Наибольший промежуток между тиками ВМ на отрезке [a, b], с концами
отрезка: сэмплер, умерший посреди нагрузки, даёт большой хвост."""
inner = [t for t in ticks_of(samples) if a < t < b]
points = [a, *inner, b]
return max(
(cur - prev for prev, cur in zip(points, points[1:], strict=False)),
default=b - a,
)
# -------------------------------------------------------------- агрегаты
def overlap(span: tuple[float, float], w0: float, w1: float) -> float:
return max(0.0, min(span[1], w1) - max(span[0], w0))
def union_length(parts: list[tuple[float, float]]) -> float:
total = 0.0
end = -math.inf
for a, b in sorted(parts):
if b <= end:
continue
total += b - max(a, end)
end = b
return total
def aggregate(series: list[Series], w0: float, w1: float) -> dict[str, Any]:
"""Агрегаты окна [w0, w1) по решению 5; несколько серий — сумма
(`api-total`): CPU складывается, максимум и пик памяти — по сумме на
одном тике."""
seconds = w1 - w0
empty = {
"present_s": None,
"cpu_mean_cores": None,
"cpu_max_cores": None,
"cpu_seconds": None,
"throttled_ratio": None,
"pressure_share": None,
"mem_peak_mib": None,
}
if seconds <= 0:
return {**empty, "flags": "empty"}
if not any(s.seen for s in series):
return {**empty, "present_s": 0.0, "flags": "absent"}
cpu = periods = throttled = pressure = 0.0
covered: list[tuple[float, float]] = []
rate_by_end: dict[float, float] = {}
for s in series:
for interval in s.intervals:
if overlap((interval.t0, interval.t1), w0, w1) <= 0:
continue
covered.append((max(interval.t0, w0), min(interval.t1, w1)))
# максимум — по всем интервалам, задевающим окно, а не только с
# концом внутри: иначе в коротком окне среднее с долями
# граничных интервалов выходило больше максимума (найдено в
# apply); посекундное значение — как в samples.csv
rate_by_end.setdefault(interval.t1, 0.0)
span = interval.span
part = overlap(span, w0, w1)
if part <= 0:
continue
share = part / (span[1] - span[0])
cpu += interval.cpu_s * share
periods += interval.periods * share
throttled += interval.throttled * share
pressure += interval.pressure_s * share
rate_by_end[interval.t1] += interval.cpu_s / interval.length
memory: dict[float, int] = {}
for s in series:
for t, value in s.memory:
if w0 <= t <= w1:
memory[t] = memory.get(t, 0) + value
present = union_length(covered)
flags = []
if present <= 0:
flags.append("absent")
elif present < seconds - PARTIAL_SLACK_S:
flags.append("partial")
if present > 0 and not rate_by_end:
flags.append("no_samples")
return {
"present_s": round(present, 2),
"cpu_mean_cores": round(cpu / seconds, 4),
"cpu_max_cores": (
round(max(rate_by_end.values()), 4) if rate_by_end else None
),
"cpu_seconds": round(cpu, 3),
"throttled_ratio": (
round(throttled / periods, 4) if periods > 0 else None
),
"pressure_share": round(pressure / seconds, 4),
"mem_peak_mib": (
round(max(memory.values()) / 2**20, 1)
if memory and any(memory.values())
else None
),
"flags": " ".join(flags),
}
def window_of(
windows: list[tuple[str, float, float]],
t: float,
) -> str | None:
for name, w0, w1 in windows:
if w0 < t <= w1:
return name
return None
def analyze(
samples: Any,
roles: dict[str, str],
windows: list[tuple[str, float, float]],
*,
ref: float,
ok_starts: list[float],
phase: str,
mode: str,
profile: str,
starts: dict[str, list[float]],
frozen: dict[str, list[tuple[float, float]]] | None = None,
) -> Result:
"""Ресурсы фазы (или замены) по окнам.
`roles` — id12 → роль (`api-target`, `postgres`, …; решение 5),
контейнеры вне него отбрасываются и возвращаются в `unmapped`.
`windows` — [(имя, начало, конец)] в секундах, первым — разгон
`warmup` (только в посекундной таблице). `ref` — опорная точка шкалы
(действие или начало замены), `ok_starts` — отправка успешных
запросов, `starts` — моменты запуска контейнеров (id12 → секунды),
`frozen` — заморозки (id12 → [(pause, unpause)]), `profile` —
`failover` или `rollout`.
"""
ticks = ticks_of(samples)
by_id = points_by_id(samples)
unmapped = sorted(ident for ident in by_id if ident not in roles)
series: dict[str, Series] = {}
for ident, points in by_id.items():
if ident not in roles:
continue
series[ident] = Series(
intervals=thaw(
container_intervals(
points,
starts.get(ident, []),
ticks,
),
(frozen or {}).get(ident, []),
),
memory=[(p[0] / 1e9, p[5]) for p in points],
)
vm = Series(intervals=vm_intervals(samples.vm), memory=[])
first_seen = {
ident: points[0][0] for ident, points in by_id.items() if points
}
def members(role: str) -> list[str]:
found = [ident for ident in series if roles[ident] == role]
return sorted(found, key=lambda i: (first_seen.get(i, 0), i))
components: list[tuple[str, str, list[Series]]] = []
expected = ROLES[profile]
extra = sorted(
{roles[i] for i in series} - set(expected),
key=lambda r: (not r.startswith("api"), r),
)
for role in (*expected, *extra):
if role == VM:
components.append((VM, "", [vm]))
elif role == TOTAL:
idents = [i for i in series if roles[i].startswith("api")]
components.append(
(TOTAL, "", [series[i] for i in idents])
if idents
else (TOTAL, "", [Series([], [], seen=False)]),
)
else:
idents = members(role)
if not idents:
components.append(
(role, "", [Series([], [], seen=False)]),
)
for ident in idents:
components.append((role, ident, [series[ident]]))
steady = STEADY[profile]
ok_sorted = sorted(ok_starts)
rows = []
for name, w0, w1 in windows:
if name == WARMUP:
continue
seconds = w1 - w0
ok = bisect.bisect_left(ok_sorted, w1) - bisect.bisect_left(
ok_sorted,
w0,
)
ok_rps = round(ok / seconds, 1) if seconds > 0 else None
for role, ident, parts in components:
values = aggregate(parts, w0, w1)
per_request = None
# контейнера в окне нет (present_s 0) — CPU на запрос не
# считается: 0 мкс выглядел бы как бесплатный запрос
if (
name in steady
and ok_rps
and values["present_s"]
and values["cpu_mean_cores"] is not None
):
per_request = round(
values["cpu_mean_cores"] * 1e6 / ok_rps,
1,
)
rows.append(
{
"phase": phase,
"mode": mode,
"window": name,
"start_s": round(w0 - ref, 2),
"end_s": round(w1 - ref, 2),
"seconds": round(seconds, 2),
"role": role,
"instance": ident,
**{k: v for k, v in values.items() if k != "flags"},
"ok_rps": ok_rps,
"us_per_ok_request": per_request,
"flags": values["flags"],
},
)
load0 = windows[0][1] if windows else 0.0
load1 = windows[-1][2] if windows else 0.0
per_second = []
named = [(ident, roles[ident], s) for ident, s in series.items()]
named.append(("", VM, vm))
for ident, role, s in named:
for interval in s.intervals:
if not load0 < interval.t1 <= load1:
continue
length = interval.length
per_second.append(
{
"phase": phase,
# окно — по концу той части интервала, где шёл CPU:
# у интервала, задевающего начало заморозки, это
# момент `pause`, как у агрегатов (`thaw`); t_s —
# по-прежнему момент отсчёта
"window": window_of(windows, interval.span[1]),
"t_s": round(interval.t1 - ref, 2),
"role": role,
"instance": ident,
"cpu_cores": round(interval.cpu_s / length, 4),
"throttled_ms": (
round(interval.throttled_s * 1000 / length, 2)
if role != VM
else None
),
"pressure_ms": round(
interval.pressure_s * 1000 / length,
2,
),
"mem_mib": (
round(interval.mem / 2**20, 1) if role != VM else None
),
},
)
order = {role: i for i, role in enumerate((*expected, *extra))}
per_second.sort(
key=lambda r: (r["t_s"], order.get(r["role"], 99), r["instance"]),
)
return Result(rows=rows, samples=per_second, unmapped=unmapped)
# ---------------------------------------------------------------- вывод
def num(value: Any) -> float | None:
if value is None or value == "":
return None
return float(value)
def cores(value: Any) -> str:
v = num(value)
return "—" if v is None else f"{v:.2f}"
def cell(row: dict[str, Any], *, present: bool = False) -> str:
"""`ср. / макс. ядер; пик МиБ` (и `(N с)`, если контейнер был не всё
окно)."""
flags = str(row.get("flags") or "").split()
if "empty" in flags:
return "пустое окно"
if num(row.get("cpu_mean_cores")) is None:
return "нет"
text = f"{cores(row['cpu_mean_cores'])} / {cores(row['cpu_max_cores'])}"
mem = num(row.get("mem_peak_mib"))
if mem is not None:
text += f"; {mem:.0f}"
if present and ("partial" in flags or "absent" in flags):
text += f" ({num(row.get('present_s')) or 0:g} с)"
return text
def per_request(row: dict[str, Any] | None) -> str:
if row is None:
return "—"
v = num(row.get("us_per_ok_request"))
return "—" if v is None else f"{v:.0f}"
def label(row: dict[str, Any]) -> str:
title = ROLE_TITLES.get(row["role"], row["role"])
return f"{title} `{row['instance']}`" if row["instance"] else title
def pick(
rows: list[dict[str, Any]],
window: str,
role: str,
) -> list[dict[str, Any]]:
return [r for r in rows if r["window"] == window and r["role"] == role]
def first(
rows: list[dict[str, Any]],
window: str,
role: str,
) -> dict[str, Any] | None:
found = pick(rows, window, role)
return found[0] if found else None
DEFINITIONS = (
"Ресурсы — сэмплер `bench/sampler.sh` в режиме `scan` (свой контейнер "
"без сети, лимит 0,25 CPU / 128 МиБ): раз в секунду счётчики cgroup "
"каждого контейнера стенда, k6 и самого сэмплера и `/proc/stat` ВМ, на "
"тех же часах ВМ, что шкала. Ячейка — среднее CPU за окно (CPU-секунды "
"/ длина окна, ядер) / наибольшее посекундное: CPU интервала между "
"отсчётами / его длина по всем интервалам, задевающим окно, включая "
"граничный (у заморозки — только с CPU в окне); строка граничного "
"интервала в `samples.csv` помечена соседним окном (окно строки — по "
"концу интервала, у заморозки — по концу незамороженной части); пик "
"памяти cgroup "
"(`memory.current`, с кэшем файлов) по отсчётам, МиБ; «(N с)» — "
"сколько секунд окна контейнер существовал, если меньше окна; «нет» — "
"контейнера не было ни в одном отсчёте. API всего — сумма по репликам, "
"пик — наибольшая сумма памяти на одном отсчёте. ВМ — занятые ядра ВМ "
"Docker целиком (в них и k6, и сэмплер). Полные значения — "
"`resources.csv`, посекундные — `samples.csv`."
)
def render_failover(
rows: list[dict[str, Any]],
phases: list[str],
) -> list[str]:
"""Раздел «Ресурсы по фазам» и таблица CPU на запрос до действия."""
titles = WINDOW_TITLES["failover"]
columns = (
TOTAL,
"api-target",
"api-other",
"postgres",
"haproxy",
"valkey",
"k6",
"sampler",
VM,
)
lines = [
"## Ресурсы по фазам",
"",
DEFINITIONS,
"",
"Окна: до действия — от первого запроса фазы + 2 с (разгон k6) до "
"действия; окно отказа — от действия до возврата; после возврата — "
"до отправки последнего запроса фазы. Цель — реплика, над которой "
"выполнено действие, вторая — другая реплика.",
"",
"| Фаза | Окно | "
+ " | ".join(ROLE_TITLES[c] for c in columns)
+ " | Успешных/с |",
"|---|---|" + "---|" * (len(columns) + 1),
]
for phase in phases:
mine = [r for r in rows if r["phase"] == phase]
for window in WINDOWS["failover"]:
cells = []
ok_rps = None
for role in columns:
row = first(mine, window, role)
cells.append(cell(row) if row else "—")
if row is not None:
ok_rps = row.get("ok_rps")
lines.append(
f"| {phase} | {titles[window]} | "
+ " | ".join(cells)
+ f" | {ok_rps if ok_rps is not None else '—'} |",
)
lines += [
"",
"### CPU на успешный запрос до действия, мкс",
"",
"CPU компонента × 10⁶ / успешных в секунду в окне до действия: обе "
"реплики в LB, ошибок нет, процессы не запускаются и не "
"останавливаются. В окне отказа и после возврата CPU на запрос не "
"считается: там CPU уходит на ошибки, ожидание зависшей реплики и "
"повторы LB, а после возврата — на запуск процесса реплики (импорт, "
"uvicorn, пул), и делитель «успешные» с этой работой не связан. Там "
"— только абсолютные числа выше. Смесь (50 % записи, 50 % чтения "
"страницы чата из 1 000 сообщений) другая, чем у серий трека 1: "
"с их CPU на запрос числа напрямую не сравниваются.",
"",
"| Фаза | " + " | ".join(ROLE_TITLES[c] for c in columns) + " |",
"|---|" + "---|" * len(columns),
]
for phase in phases:
mine = [r for r in rows if r["phase"] == phase]
lines.append(
f"| {phase} | "
+ " | ".join(
per_request(first(mine, "before", role)) for role in columns
)
+ " |",
)
lines.append("")
return lines
def render_failover_phase(
rows: list[dict[str, Any]],
phase: str,
) -> list[str]:
"""Таблица «компонент × окно» в разделе фазы."""
titles = WINDOW_TITLES["failover"]
mine = [r for r in rows if r["phase"] == phase]
if not mine:
return []
lines = [
"Ресурсы фазы: ср. / макс. ядер; пик памяти, МиБ (секунд в окне, "
"если контейнер был не всё окно).",
"",
"| Компонент | "
+ " | ".join(titles[w] for w in WINDOWS["failover"])
+ " |",
"|---|" + "---|" * len(WINDOWS["failover"]),
]
for role in ROLES["failover"]:
for row in pick(mine, "before", role):
cells = []
for window in WINDOWS["failover"]:
match = next(
(
r
for r in pick(mine, window, role)
if r["instance"] == row["instance"]
),
None,
)
cells.append(cell(match, present=True) if match else "—")
lines.append(f"| {label(row)} | " + " | ".join(cells) + " |")
lines.append("")
return lines
def render_rollout(rows: list[dict[str, Any]]) -> list[str]:
"""Раздел «Ресурсы по окнам замены»."""
titles = WINDOW_TITLES["rollout"]
windows = WINDOWS["rollout"]
head = []
for window in windows:
row = next((r for r in rows if r["window"] == window), None)
span = (
f" ({num(row['start_s']):g}…{num(row['end_s']):g} с)"
if row
else ""
)
head.append(titles[window] + span)
lines = [
"## Ресурсы по окнам замены",
"",
DEFINITIONS,
"",
"Окна (секунды от начала замены): до — от первого запроса + 2 с "
"(разгон k6) до первого обращения скрипта к стенду (`exec_start` в "
"событиях проекта, кроме проверок здоровья контейнеров); подготовка "
"— проверки скрипта и сборка образа "
"до создания контейнера миграции; замена — до удаления последней "
"старой реплики; после — до отправки последнего запроса. Старые и "
"новые реплики — каждая отдельно со своим `X-Instance-Id`; на пике "
"замены работают три реплики.",
"",
"| Компонент | " + " | ".join(head) + " |",
"|---|" + "---|" * len(windows),
]
prepare = [r for r in rows if r["window"] == "prepare"]
if prepare and all("empty" in str(r["flags"]) for r in prepare):
lines[4] += (
" Начало подготовки не найдено: окно «подготовка» пусто, «до» "
"кончается на начале замены."
)
order = [*ROLES["rollout"]]
order += sorted({r["role"] for r in rows} - set(order))
for role in order:
for row in pick(rows, "before", role) or pick(rows, "during", role):
cells = []
for window in windows:
match = next(
(
r
for r in pick(rows, window, role)
if r["instance"] == row["instance"]
),
None,
)
cells.append(cell(match, present=True) if match else "—")
lines.append(f"| {label(row)} | " + " | ".join(cells) + " |")
steady = STEADY["rollout"]
lines += [
"",
"### CPU на успешный запрос до и после замены, мкс",
"",
"CPU компонента × 10⁶ / успешных в секунду в окнах до и после: две "
"реплики одной версии, скрипт не работает. В подготовке и замене CPU "
"на запрос не считается: CPU там идёт на сборку образа, миграцию, "
"запуск третьей реплики, дренаж и остановку старой — цену процедуры, "
"а не запросов; там — только абсолютные числа выше. Смесь (50 % "
"записи, 50 % чтения страницы чата из 1 000 сообщений) другая, чем у "
"серий трека 1: с их CPU на запрос числа напрямую не сравниваются.",
"",
"| Компонент | " + " | ".join(titles[w] for w in steady) + " |",
"|---|" + "---|" * len(steady),
]
for role in (TOTAL, "postgres", "haproxy", "valkey", "k6", "sampler", VM):
lines.append(
f"| {ROLE_TITLES[role]} | "
+ " | ".join(per_request(first(rows, w, role)) for w in steady)
+ " |",
)
ok = [
f"{titles[w]} {first(rows, w, VM)['ok_rps']}"
for w in windows
if first(rows, w, VM) is not None
]
lines += ["", "Успешных в секунду по окнам: " + ", ".join(ok) + ".", ""]
return lines
def terminal_line(rows: list[dict[str, Any]], profile: str) -> str:
"""Строка ресурсов фазы в терминал: средние ядра по окнам."""
windows = WINDOWS[profile]
roles = (
(TOTAL, "api-target", "postgres", VM, "sampler")
if profile == "failover"
else (TOTAL, "migrate", "postgres", VM, "sampler")
)
parts = []
for role in roles:
values = []
for window in windows:
row = first(rows, window, role)
values.append(cores(row["cpu_mean_cores"]) if row else "—")
parts.append(f"{ROLE_TITLES[role]} {'/'.join(values)}")
return f"resources, mean cores {'/'.join(windows)}: " + ", ".join(parts)
# ------------------------------------------------------- самопроверка
def selftest() -> int:
"""Синтетические строки сэмплера (решение 12)."""
failures: list[str] = []
def expect(name: str, got: Any, want: Any, tol: float = 1e-6) -> None:
if isinstance(want, float) and isinstance(got, float | int):
if abs(got - want) > tol:
failures.append(f"{name}: got {got!r}, want {want!r}")
return
if got != want:
failures.append(f"{name}: got {got!r}, want {want!r}")
base = 1_800_000_000
mib = 2**20
def ns(t: float) -> int:
return int(round((base + t) * 1e9))
lines: list[str] = []
def cg(t: float, ident: str, usage: float, mem: int, **kw: int) -> None:
lines.append(
f"cg {ns(t)} - {ident} {int(usage * 1e6)} "
f"{kw.get('periods', 0)} {kw.get('throttled', 0)} "
f"{kw.get('thr', 0)} {mem} {kw.get('psi', 0)}",
)
ids = {
"steady": "a" * 12,
"stopped": "b" * 12,
"paused": "c" * 12,
"new": "d" * 12,
"gap": "e" * 12,
"alien": "f" * 12,
}
# тики 0…14, ВМ: 2 ядра заняты (200 jiffies в секунду)
for i in range(15):
lines.append(f"vm {ns(i)} {200 * i} {1200 * i} {1000 * i}")
# непрерывный: 0,5 ядра, троттлинг в каждом десятом периоде
cg(
i,
ids["steady"],
0.5 * i,
100 * mib,
periods=10 * i,
throttled=i,
)
# остановлен после тика 5, запущен в 9,6 (новая cgroup): на тике 10
# 0,2 с от запуска, дальше 0,5 ядра
if i <= 5:
cg(i, ids["stopped"], 10 + 0.5 * i, 80 * mib)
elif i >= 10:
cg(i, ids["stopped"], 0.2 + 0.5 * (i - 10), 60 * mib)
# заморожен с 5 до 9,6: счётчик стоит, память та же; дальше 0,4
if i <= 5:
usage = 0.4 * i
elif i <= 9:
usage = 2.0
else:
usage = 2.16 + 0.4 * (i - 10)
cg(i, ids["paused"], usage, 70 * mib)
# новая реплика: запуск 6,4, на тике 7 — 0,3 с, дальше 0,6 ядра
if i >= 7:
cg(i, ids["new"], 0.3 + 0.6 * (i - 7), 90 * mib)
# ложный пропуск тиков 4 и 5 без сброса: 0,25 ядра непрерывно
if i not in (4, 5):
cg(i, ids["gap"], 0.25 * i, 50 * mib)
cg(i, ids["alien"], 5.0 * i, 10 * mib)
samples = scaling.parse_samples("\n".join(lines))
roles = {
ids["steady"]: "postgres",
ids["stopped"]: "api-target",
ids["paused"]: "api-other",
ids["new"]: "k6",
ids["gap"]: "haproxy",
}
t = base
windows = [
(WARMUP, t + 0.0, t + 2.0),
("before", t + 2.0, t + 5.5),
("down", t + 5.5, t + 9.6),
("after", t + 9.6, t + 14.0),
]
ok_starts = [t + 2.0 + k / 100 for k in range(350)]
result = analyze(
samples,
roles,
windows,
ref=t + 5.5,
ok_starts=ok_starts,
phase="01-stop-r1",
mode="stop",
profile="failover",
starts={ids["stopped"]: [t + 9.6], ids["new"]: [t + 6.4]},
)
def row(window: str, role: str) -> dict[str, Any]:
found = first(result.rows, window, role)
assert found is not None, (window, role)
return found
expect("unmapped", result.unmapped, [ids["alien"]])
expect(
"rows",
len(result.rows),
len(WINDOWS["failover"]) * len(ROLES["failover"]),
)
# непрерывный контейнер; деление интервала на границе окна
expect("steady before", row("before", "postgres")["cpu_mean_cores"], 0.5)
expect("steady seconds", row("before", "postgres")["cpu_seconds"], 1.75)
expect("steady max", row("before", "postgres")["cpu_max_cores"], 0.5)
expect(
"steady throttled",
row("before", "postgres")["throttled_ratio"],
0.1,
)
expect("steady mem", row("before", "postgres")["mem_peak_mib"], 100.0)
expect("steady flags", row("before", "postgres")["flags"], "")
# остановка, пропуск тиков и запуск со сбросом
down = row("down", "api-target")
expect("stopped down cpu", down["cpu_mean_cores"], 0.0)
expect("stopped down present", down["present_s"], 0.0)
expect("stopped down flags", down["flags"], "absent")
after = row("after", "api-target")
expect("stopped after seconds", after["cpu_seconds"], 2.2)
expect("stopped after max", after["cpu_max_cores"], 0.5)
expect("stopped after mem", after["mem_peak_mib"], 60.0)
# CPU после последнего отсчёта до остановки (5 → 5,5) не виден
expect("stopped before", row("before", "api-target")["cpu_seconds"], 1.5)
# пауза: прирост 0, память та же, присутствует всё окно; в окно
# попадает только доля интервала разморозки (9; 10] — 0,16 × 0,6
paused = row("down", "api-other")
expect("paused cpu", paused["cpu_seconds"], 0.096)
# максимум — по интервалам, задевающим окно: (9; 10] после разморозки
expect("paused max", paused["cpu_max_cores"], 0.16)
expect("paused mem", paused["mem_peak_mib"], 70.0)
expect("paused flags", paused["flags"], "")
# заморозка из событий (5,3 … 9,6): CPU интервала разморозки — после
# unpause, окно отказа — без прироста
thawed = analyze(
samples,
roles,
windows,
ref=t + 5.5,
ok_starts=ok_starts,
phase="02-pause-r2",
mode="pause",
profile="failover",
starts={ids["stopped"]: [t + 9.6], ids["new"]: [t + 6.4]},
frozen={ids["paused"]: [(t + 5.3, t + 9.6)]},
)
expect(
"thawed down cpu",
first(thawed.rows, "down", "api-other")["cpu_seconds"],
0.0,
)
expect(
"thawed down max",
first(thawed.rows, "down", "api-other")["cpu_max_cores"],
0.0,
)
expect(
"thawed after",
first(thawed.rows, "after", "api-other")["cpu_seconds"],
0.16 + 0.4 * 4,
)
expect(
"thawed present",
first(thawed.rows, "down", "api-other")["flags"],
"",
)
# `pause` ровно на действии, как в фазе: 0,5 ядра до 5,5, заморозка
# до 9,6, дальше 0,5. Интервал (5; 6] несёт 0,25 с CPU до `pause`:
# его строка в samples.csv — в окне до действия, у цели в окне отказа
# нет строк с CPU > 0
lines.clear()
for i in range(15):
lines.append(f"vm {ns(i)} {200 * i} {1200 * i} {1000 * i}")
if i <= 5:
usage = 0.5 * i
elif i <= 9:
usage = 2.75
else:
usage = 2.95 + 0.5 * (i - 10)
cg(i, ids["paused"], usage, 70 * mib)
paused_phase = analyze(
scaling.parse_samples("\n".join(lines)),
{ids["paused"]: "api-target"},
windows,
ref=t + 5.5,
ok_starts=ok_starts,
phase="05-pause-r1",
mode="pause",
profile="failover",
starts={},
frozen={ids["paused"]: [(t + 5.5, t + 9.6)]},
)
target = [r for r in paused_phase.samples if r["role"] == "api-target"]
expect(
"pause samples down",
[r["cpu_cores"] for r in target if r["window"] == "down"],
[0.0, 0.0, 0.0],
)
expect(
"pause samples before",
[
(r["t_s"], r["cpu_cores"])
for r in target
if r["window"] == "before" and r["t_s"] > 0
],
[(0.5, 0.25)],
)
expect(
"pause samples after",
next(r["cpu_cores"] for r in target if r["t_s"] == 4.5),
0.2,
)
pause_rows = {
w: first(paused_phase.rows, w, "api-target")
for w in WINDOWS["failover"]
}
expect("pause before cpu", pause_rows["before"]["cpu_seconds"], 1.75)
expect("pause down cpu", pause_rows["down"]["cpu_seconds"], 0.0)
expect("pause down max", pause_rows["down"]["cpu_max_cores"], 0.0)
expect("pause after cpu", pause_rows["after"]["cpu_seconds"], 2.2)
# новая реплика: CPU от момента запуска, первый интервал (6,4; 7]
k6 = row("down", "k6")
expect("new seconds", k6["cpu_seconds"], 0.3 + 0.6 * 2 + 0.6 * 0.6)
expect("new max", k6["cpu_max_cores"], 0.6)
expect("new present", k6["present_s"], 9.6 - 6.4)
expect("new flags", k6["flags"], "partial")
expect("new before", row("before", "k6")["flags"], "absent")
# ложный пропуск без сброса — продолжение с тем же темпом
expect("gap down", row("down", "haproxy")["cpu_mean_cores"], 0.25)
expect("gap before", row("before", "haproxy")["cpu_mean_cores"], 0.25)
# сумма по репликам и пик суммарной памяти
total = row("before", TOTAL)
expect("total cpu", total["cpu_seconds"], 1.5 + 1.2)
expect("total mem", total["mem_peak_mib"], 150.0)
expect("total down mem", row("down", TOTAL)["mem_peak_mib"], 70.0)
expect("total after max", row("after", TOTAL)["cpu_max_cores"], 0.9)
# ВМ: 2 ядра, PSI 1 мс/с
expect("vm cpu", row("before", VM)["cpu_mean_cores"], 2.0)
expect("vm pressure", row("before", VM)["pressure_share"], 0.001)
# CPU на запрос только в установившемся окне: 100 успешных/с
expect("ok rps", row("before", VM)["ok_rps"], 100.0)
expect(
"per request before",
row("before", "postgres")["us_per_ok_request"],
5000.0,
)
expect(
"per request down",
row("down", "postgres")["us_per_ok_request"],
None,
)
expect(
"per request after",
row("after", "postgres")["us_per_ok_request"],
None,
)
# контейнера в окне нет — CPU на запрос не считается, а не 0
expect(
"per request absent",
row("before", "k6")["us_per_ok_request"],
None,
)
# посекундная таблица: без чужого, с окнами и секундами от действия
roles_seen = {r["role"] for r in result.samples}
expect(
"samples alien",
ids["alien"] in {r["instance"] for r in result.samples},
False,
)
expect("samples roles", "vm" in roles_seen and "k6" in roles_seen, True)
first_new = min(
r["t_s"] for r in result.samples if r["instance"] == ids["new"]
)
expect("samples new first", first_new, 1.5)
windows_seen = {r["window"] for r in result.samples}
expect(
"samples windows",
windows_seen,
{WARMUP, "before", "down", "after"},
)
# сторож: тики раз в секунду; хвост без тиков — большой промежуток
expect("gap ok", max_gap(samples, t + 1.5, t + 14.0), 1.0)
expect("gap tail", max_gap(samples, t + 1.5, t + 20.0), 6.0)
# пустое окно (начало подготовки не найдено)
empty = aggregate([Series([], [])], t + 3, t + 3)
expect("empty window", empty["flags"], "empty")
# рендер не падает и называет причину пустых ячеек
text = "\n".join(
render_failover(result.rows, ["01-stop-r1"])
+ render_failover_phase(result.rows, "01-stop-r1"),
)
expect("render reason", "делитель «успешные»" in text, True)
expect("terminal", terminal_line(result.rows, "failover")[:9], "resources")
# замена: роли старых и новых, пустая подготовка, CPU на запрос до и
# после, рендер раздела
rollout = analyze(
samples,
{
ids["stopped"]: "api-old",
ids["paused"]: "api-old",
ids["new"]: "api-new",
ids["steady"]: "postgres",
},
[
(WARMUP, t + 0.0, t + 2.0),
("before", t + 2.0, t + 5.0),
("prepare", t + 5.0, t + 5.0),
("during", t + 5.0, t + 10.0),
("after", t + 10.0, t + 14.0),
],
ref=t + 5.0,
ok_starts=ok_starts,
phase="rollout",
mode="rollout",
profile="rollout",
starts={ids["new"]: [t + 6.4]},
)
expect(
"rollout rows",
len(rollout.rows),
4 * (len(ROLES["rollout"]) + 1),
)
expect(
"rollout migrate",
first(rollout.rows, "during", "migrate")["flags"],
"absent",
)
expect(
"rollout prepare",
first(rollout.rows, "prepare", "postgres")["flags"],
"empty",
)
expect(
"rollout per request",
[
first(rollout.rows, w, "postgres")["us_per_ok_request"] is None
for w in WINDOWS["rollout"]
],
[False, True, True, True],
)
text = "\n".join(render_rollout(rollout.rows))
expect("rollout render", "Начало подготовки не найдено" in text, 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/resources.py --selftest", flush=True)
sys.exit(2)