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")