Full cell hover explanations: dashboard_suggestions.json
cpu_sec_report / duration_sec.1/2/4/8/16. It reflects only observed per-chunk core usage. REQUIREMENTS(cpu) is a per-chunk scheduler slot (reserved cores that cap how many chunks run in parallel), not a request for more raw CPU.--maximize-reqs-for-timeout-tests is enabled, suites crossing the duration threshold additionally use size max: SMALL=1, MEDIUM=4, LARGE=4.sum > size_timeout*0.98) are detected even without a timeout (split_severity=at_risk); with a timeout it is timeout. Required chunk count is ceil(overloaded_total / (size_timeout*0.5)), and a single very heavy chunk is split into ceil(max_chunk_load / (size_timeout*0.5)) pieces. If a single test alone is at/above the budget (single_test_blocks_split), SPLIT_FACTOR cannot help. In that case, if the test is only marginally over budget and the runner was CPU-saturated during the suite window (single_test_contention_suspected, from resources_monitor.jsonl), it is likely contention-inflated — TRY raising REQUIREMENTS(cpu) (fewer parallel chunks → decontention) before a test-level fix; otherwise (genuinely long) the fix is TIMEOUT() / reduce work / mute.ya_cpu. A lower suggestion is suppressed (kept ok) while the suite is under split/time pressure, because a smaller cpu slot increases parallel chunks and can worsen timeouts/OOM.ya make -t scheduler caps parallelism only by cpu (sum of REQUIREMENTS(cpu) ≤ cores). REQUIREMENTS(ram) is not honored locally, so it is never recommended. Instead max_chunk_ram (physical peak of the heaviest chunk) is turned into cpu_for_memory: allow at most floor(mem_budget / max_chunk_ram) parallel chunks, i.e. cpu ≈ ceil(cores / that) (provisioned runner ≈ 64 cores / 256.0 GB, per-suite budget ≈ 179.2 GB). Purple dashed lines on system charts mark provisioned limits from .github/config/runners_footprints.yml; the red monitor line is actual /proc usage (may be lower). When cpu_for_memory > p95 cpu, recommended_cpu is raised to it (shown red) to prevent OOM.chunk=true. total = all chunk rows, passed = status OK/PASS.chunk=false (regular tests, suite aggregate row excluded). total = all such rows, passed = status OK/PASS.error_type == TIMEOUT (fallback: status contains timeout).muted/is_muted or status MUTE.SKIP or SKIPPED.errors + timeouts.t we sum each active chunk contribution. For CPU it is cpu_sec_report / duration_used_sec (average cores for that run); for RAM it is the chunk memory metric from report converted to GB. This is a model by chunks, not an instantaneous per-process sample./proc during the run (actual usage).runners_footprints.yml for this build preset. Optional dotted line: ya.make cgroup RAM cap (~243.2 GB).duration_report_sec from report; duration_evlog_sec from evlog B/E. For CPU/cores we use duration_used_sec = max(report, evlog).cpu_sec_report = ru_utime + ru_stime from report metrics (seconds).cores_est = cpu_sec_report / duration_used_sec (duration_used_sec = max(report, evlog)). Chart value at time t is the sum of active chunks at t.ram_kb_report = max(0, suite_max_proc_tree_memory_consumption_kb − suite_initial_maxrss_(kb)) when both suite metrics exist (memory attributed to the test run); else suite_max_proc_tree_memory_consumption_kb; else ru_maxrss; fallback ru_rss / 1024.ram_gb = ram_kb_report / (1024 * 1024). Chart value at time t is the sum of active chunks at t.REQUIREMENTS(cpu:X ram:Y): cpu_sec_report = X * evlog_dur_sec, ram_kb_report = Y * 1024 * 1024.tests means tests in chunks that are active at that cursor moment (not total tests in suite).ya_split_factor is the effective split from ya.make (with FORK_TEST_FILES: TEST_SRCS count × SPLIT_FACTOR(N)). Column chunks is real runtime chunk count. Hover cells for details. Highlight on chunks means mismatch with ya.make.T = size_timeout_sec (from SIZE), B = 0.98 * T (chunk timeout budget),
and L = 0.5 * T (target chunk load). For each chunk we compute
sum_duration_sec(chunk) from test durations in that chunk.
Overloaded chunks are those with sum_duration_sec > B.
Then:
overloaded_total = Σ sum_duration_sec(overloaded chunks),
needed = ceil(overloaded_total / L),
extra = max(0, needed - overloaded_chunks_count).
A single heavy chunk also forces single_chunk_extra = ceil(max_chunk_load / L) - 1,
and recommended_split = chunks_real + max(extra, single_chunk_extra).
Overloaded chunks are detected regardless of timeouts: split_severity is
at_risk when a chunk is over budget without a timeout, timeout once a
timeout occurs. If no chunk exceeds the budget, split is not raised.
t is Σ cpu_sec_report / dur_sec over all runs of the suite active at t. Table total_cpu_sec / total_dur_sec is from one deduplicated run — so e.g. 89.4/135.3 ≈ 0.66 cores is not the same as a stacked chart reading of hundreds of cores from many parallel parts.