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.
Per run (we use dur_sec = max(duration_report_sec, duration_evlog_sec) so cores are not inflated when evlog span is short):
cpu_cores_estrun = cpu_sec_report / dur_sec
Chart value at time t (we use all runs, not one chunk):
value(t) = Σ cpu_cores_estrun over all runs of this suite where start_us ≤ t < end_us.
So at each moment we sum estimated cores of every run that is active. If a suite has many parallel runs (e.g. part0..part19), the chart shows the sum of all of them at that time.
Table columns total_cpu_sec / total_dur_sec are from the deduplicated set (one run per suite+chunk for recommendations). So e.g. total_cpu_sec=89.4 and total_dur_sec=135.3 refer to one representative run; 89.4/135.3 ≈ 0.66 cores is the average for that run. The chart value (e.g. 373 cores) is not 89.4/135.3 — it is the sum of cpu_sec_report/dur_sec over all runs of the suite active at the cursor time (e.g. 40 runs × ~9.3 cores ≈ 373).
Per run: cpu_cores_est = cpu_sec_report / dur_sec (we have real report for every run).
At time t: value = Σ cpu_cores_est over all runs of this suite with start_us ≤ t < end_us. We do not use one chunk — we sum over all active runs.
Why value (e.g. 373) ≠ total_cpu_sec/total_dur_sec (e.g. 89.4/135.3): The table totals are from the deduplicated run (one row per suite); the chart value is the instantaneous sum over all runs active at that moment (e.g. many parts in parallel).