"""Ресурсы профилей уровня «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)