A sample interval that crosses docker pause or unpause carried the CPU spent before the pause and the burst after unpause into the failover window by proportional split. Use the pause and unpause moments from Docker events so that interval CPU lands outside the frozen span. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1174 lines
44 KiB
Python
1174 lines
44 KiB
Python
"""Ресурсы профилей уровня «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
|
||
if (
|
||
name in steady
|
||
and ok_rps
|
||
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,
|
||
"window": window_of(windows, interval.t1),
|
||
"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-секунды "
|
||
"/ длина окна, ядер) / наибольшее посекундное; пик памяти 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"],
|
||
"",
|
||
)
|
||
# новая реплика: 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,
|
||
)
|
||
# посекундная таблица: без чужого, с окнами и секундами от действия
|
||
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)
|