fix: attribute replica CPU around pause to the unfrozen part

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>
This commit is contained in:
2026-10-12 18:09:05 +03:00
co-authored by Claude Opus 5.5
parent 6505b5e929
commit 2d267bfbe6
3 changed files with 106 additions and 28 deletions
+3 -1
View File
@@ -197,7 +197,9 @@ paths:
— их число). Окна фазы: до действия (от первого запроса + 2 с), окно
отказа (действие → возврат), после возврата (до последнего запроса);
`docker start` после `stop` / `kill` — новая cgroup, её счёт идёт с
момента возврата. CPU на успешный запрос — только до действия.
момента возврата; у `pause` … `unpause` CPU интервалов, задевающих
заморозку, относится к её внешней части. CPU на успешный запрос —
только до действия.
Разбор и агрегаты — `resources.py` (`--selftest`). Сторож: сэмплер
остановился или тиков нет дольше 3 с в нагрузке — отказ с фазой.
Сумма лимитов CPU на пике и сэмплера больше CPU ВМ — код 2 до стенда
+96 -25
View File
@@ -140,11 +140,18 @@ class Interval:
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:
@@ -259,6 +266,31 @@ def container_intervals(
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 = []
@@ -296,8 +328,8 @@ def max_gap(samples: Any, a: float, b: float) -> float:
# -------------------------------------------------------------- агрегаты
def overlap(interval: Interval, w0: float, w1: float) -> float:
return max(0.0, min(interval.t1, w1) - max(interval.t0, w0))
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:
@@ -334,24 +366,24 @@ def aggregate(series: list[Series], w0: float, w1: float) -> dict[str, Any]:
rate_by_end: dict[float, float] = {}
for s in series:
for interval in s.intervals:
part = overlap(interval, w0, w1)
if part > 0:
share = part / interval.length
cpu += interval.cpu_s * share
periods += interval.periods * share
throttled += interval.throttled * share
pressure += interval.pressure_s * share
covered.append(
(max(interval.t0, w0), min(interval.t1, w1)),
)
# максимум — по всем интервалам, задевающим окно, а не только
# с концом внутри: иначе в коротком окне среднее с долями
# граничных интервалов выходило больше максимума (найдено в
# apply)
rate_by_end[interval.t1] = (
rate_by_end.get(interval.t1, 0.0)
+ interval.cpu_s / interval.length
)
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:
@@ -406,6 +438,7 @@ def analyze(
mode: str,
profile: str,
starts: dict[str, list[float]],
frozen: dict[str, list[tuple[float, float]]] | None = None,
) -> Result:
"""Ресурсы фазы (или замены) по окнам.
@@ -415,7 +448,8 @@ def analyze(
`warmup` (только в посекундной таблице). `ref` — опорная точка шкалы
(действие или начало замены), `ok_starts` — отправка успешных
запросов, `starts` — моменты запуска контейнеров (id12 → секунды),
`profile` — `failover` или `rollout`.
`frozen` — заморозки (id12 → [(pause, unpause)]), `profile` —
`failover` или `rollout`.
"""
ticks = ticks_of(samples)
by_id = points_by_id(samples)
@@ -425,10 +459,13 @@ def analyze(
if ident not in roles:
continue
series[ident] = Series(
intervals=container_intervals(
points,
starts.get(ident, []),
ticks,
intervals=thaw(
container_intervals(
points,
starts.get(ident, []),
ticks,
),
(frozen or {}).get(ident, []),
),
memory=[(p[0] / 1e9, p[5]) for p in points],
)
@@ -972,6 +1009,40 @@ def selftest() -> int:
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)
+7 -2
View File
@@ -3178,6 +3178,7 @@ class Bench:
# секунды часов ВМ) и ID вне стенда за весь прогон
self.containers: dict[str, dict[str, str]] = {}
self.starts: dict[str, list[float]] = {}
self.frozen: dict[str, list[tuple[float, float]]] = {}
self.unmapped: set[str] = set()
# ------------------------------------------------------------ вывод
@@ -4603,11 +4604,14 @@ class Bench:
`profile-resources`): разгон — 2 с с первого запроса, до действия,
окно отказа до возврата, после возврата до последнего запроса.
`docker start` после `stop` / `kill` — новая cgroup, её счёт идёт
с момента возврата."""
с момента возврата; `pause` … `unpause` — заморозка: CPU
граничных интервалов — вне её."""
first = min(r.start for r in requests)
last = max(r.start for r in requests)
self.check_observer(f"phase {phase}", first, last)
if mode != "pause":
if mode == "pause":
self.frozen.setdefault(instance, []).append((action, back))
else:
self.starts.setdefault(instance, []).append(back)
self.containers.update(self.stand.container_map())
roles = {}
@@ -4632,6 +4636,7 @@ class Bench:
mode=mode,
profile="failover",
starts=self.starts,
frozen=self.frozen,
)
self.observe(result, f"phase {phase}", "failover")