From 2d267bfbe6813f0d6f8630c186b859ef636fd832 Mon Sep 17 00:00:00 2001 From: roman Date: Mon, 12 Oct 2026 18:09:05 +0300 Subject: [PATCH] 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 --- .claude/rules/bench.md | 4 +- bench/resources.py | 121 ++++++++++++++++++++++++++++++++--------- bench/run.py | 9 ++- 3 files changed, 106 insertions(+), 28 deletions(-) diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index 90a09682..6699f04c 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -197,7 +197,9 @@ paths: — их число). Окна фазы: до действия (от первого запроса + 2 с), окно отказа (действие → возврат), после возврата (до последнего запроса); `docker start` после `stop` / `kill` — новая cgroup, её счёт идёт с - момента возврата. CPU на успешный запрос — только до действия. + момента возврата; у `pause` … `unpause` CPU интервалов, задевающих + заморозку, относится к её внешней части. CPU на успешный запрос — + только до действия. Разбор и агрегаты — `resources.py` (`--selftest`). Сторож: сэмплер остановился или тиков нет дольше 3 с в нагрузке — отказ с фазой. Сумма лимитов CPU на пике и сэмплера больше CPU ВМ — код 2 до стенда diff --git a/bench/resources.py b/bench/resources.py index a11a595f..dc18c1a8 100644 --- a/bench/resources.py +++ b/bench/resources.py @@ -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) diff --git a/bench/run.py b/bench/run.py index 7bca2622..73db3f6a 100644 --- a/bench/run.py +++ b/bench/run.py @@ -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")