EAGLE4 Trace: what every block is doing during a draft step
EAGLE4 Trace converts xsim cycle logs, box1 host-side profiles and (once added) on-card counters
into Chrome Trace JSON for ui.perfetto.dev. Each card, the GPU and the host is a process.
Each hardware block of the architecture diagram is a track. Slices are stages, items and levels; arrows are hand-offs (seam HEAD→TAIL, host relay, verify).
analyze.py marks every idle gap as a bubble, infers its cause, and summarises utilisation per engine.
Every number is labelled M measured, D derived or P projected.
Swimlanes
Use the wheel to zoom and drag to pan. Hover a slice for its args. Grey hatched slices are bubbles, labelled with their inferred cause. Each row is one diagram block: label [block id · clock]. The block chips below link to the architecture report.
Utilisation per engine
The what-if column P is the projected step if that engine's top bubble were removed: span − min(top-cause bubble, the time the causing engines run alone on the critical path). It is an upper bound on the gain. Removing one bubble can expose the next dependency.
What it shows
- Silicon step (b), steps 52–54 (walls 16.5–19.8 ms, near the 18.2 ms steady median) D from M spans: the HEAD card is busy 5–17 % of the step and the TAIL 11–25 %; the GPU 36–47 %; host spans 29–38 %. Both cards' top bubble is waiting on GPU (29–44 %), the GPU's is waiting on FPGA draft (35–44 %), and the host's is waiting on cards. Another 14–26 % of each card's step is in FPGA chain, not itemised: the host is in the join but the relay stamps no card interval. The step is a serial host → cards → GPU chain. Overlapping the draft with verify P (what-if GPU −10…−30 %, an upper bound) is worth more than speeding up one engine. (Recorded 10-03 on the degraded platform: SMI storm plus the crash loop.)
- xsim level (a) D: the h_array GEMV is busy 63 % of the level window, with the TAIL result as its top bubble (24 %). The TAIL stages are 2–13 % busy each because they run serially per level.
- AC4 (c) D: the 4-card X step is 31.7 ms vs 21.7 ms for P. KV loads take 7.07 ms vs 2.04 ms per step, which is half of the gap. Everything else in (c) restates an assumed split.
Collecting a trace
All file:line citations are for the files in this directory unless a path is given.
1. Trace format contract (schema eagle4-trace/1)
The output is one JSON object: {"traceEvents": [...], "displayTimeUnit": "ns", "otherData": {...}}, written by Trace.write (eagle4trace.py:134-141).
| Field | Type / unit | Meaning in EAGLE4 Trace | Emitted at |
|---|---|---|---|
otherData.schema | string | Format version, "eagle4-trace/1" (SCHEMA_VERSION, bumped on any field change). | eagle4trace.py:58, :136 |
otherData.title, .tool, .labels | string | Trace title, "EAGLE4 Trace v1", and the label legend. Converters can add keys (e.g. summary_us). | eagle4trace.py:136-137 |
displayTimeUnit | "ns" | Display hint only. It does not change the unit of ts/dur. | eagle4trace.py:135 |
ph | string | Event type. Emitted: X complete slice, i instant, C counter, s/f flow start/end, M metadata. Not emitted: B/E, flow step t, bind_id. | see the rows below |
name | string | Slice name: stage, item, level, or bubble: <cause>. A counter name carries its label: "<name> [M|D|P]". | eagle4trace.py:95, :105 |
cat | string | For X: the diagram block id, "bubble" for analyzer bubbles, "flow" for flows. | eagle4trace.py:96, :111; analyze.py:120 |
ts | float, µs | Start time from the trace origin, rounded to 1 ns. | eagle4trace.py:95 |
dur | float, µs | X only; clamped to ≥ 0. | eagle4trace.py:95 |
pid | int | One per process: HOST 1, GPU 2, HEAD 10, TAIL 20, HEAD2 30, TAIL2 40, LINK 50. | eagle4trace.py:20 |
tid | int | Integer index of the track in TRACKS (1-based, in dict order), not the block-id string. The block id is in args.block and in the thread name; block_track_map.tsv lists track → block. | eagle4trace.py:23-57 |
id | int (flows) / string (util counters) | Flow pairing id (s and f share it). On util counters it is the analysis window name. | eagle4trace.py:111-112; analyze.py:112 |
s | "t" | Instant scope = thread. | eagle4trace.py:101 |
bp | "e" | Flow end binds to the enclosing slice. | eagle4trace.py:112 |
args.label | "M"/"D"/"P" | Fidelity of the timing (on every X and i; on C it is in name). | eagle4trace.py:91, :100 |
args.src | string | Source description (log run / hostprof file). xsim slices also carry args.src_line = <log file>:<line> of the monitor line used. | eagle4trace.py:91; xsim2trace.py:98-99 |
args.block | string | Diagram block id of the track. | eagle4trace.py:91 |
args.clock | string | Clock-domain label of the track, e.g. "usr_1 132 MHz (2:1)". | eagle4trace.py:91 |
args.clock_mhz | float | Numeric MHz of the track's clock, set when the label has N MHz (not on CPU/GPU/link/HBM tracks). | eagle4trace.py:61-65, :92-93 |
args.cycles, args.cycle_clock_mhz | int, float | xsim only: TB-clock cycles of the slice and the silicon clock used to convert them (dur = cycles / cycle_clock_mhz). HEAD stage cycles are counted in the top-FSM domain, so h_array slices have cycle_clock_mhz 66 while their track clock_mhz is 132. | xsim2trace.py:98-99, :133-134 |
args.item, args.level | int | xsim HEAD: ITEMMON done_seq and lvl_max. TAIL: level (0 for first-level stages, idx on t_lvl slices). | xsim2trace.py:98, :104-106, :115-117, :143 |
args.step, args.raw, args.kind | int, string | hostprof: decode-step index, original hostprof label, card interval kind (item/kvonly/commit). | hostprof2trace.py:44-62 |
args.bubble | bool | true on slices that are waiting, not work: xsim WAIT, host envelopes (draft_fpga_tree_v14, cf._card_join, sglang.target_model_verify), analyzer bubbles. Busy-time accounting skips them. | xsim2trace.py:104-106; hostprof2trace.py:20, :47; eagle4trace.py:153-154 |
args.cause | string | Analyzer bubbles only: the inferred cause. | analyze.py:121 |
args.resolution_us | float | cardctr level slices: the poll period (± timing). | cardctr2trace.py:90-91 |
Counters (ph: C) live on the process (no tid). Each key in args is one numeric series.
| Name | Series (unit) | Label | Emitted at |
|---|---|---|---|
KV rows written [M] | kv_rows (KVWR monitor lines per item) | M | xsim2trace.py:108 |
TREE serializer FIFO occupancy [M] | occupancy, capacity, survivors (entries) | M | xsim2trace.py:146 |
util <track> [D] | busy_pct, bubble_pct (% of the window; two points, window start and end) | D | analyze.py:109-113 |
pipe_lvl_count [M] | lvl (CSR 0x19c value) | M | cardctr2trace.py:84 |
boot_drop / tp_drop [M] | boot_drop, tp_drop (counts) | M | cardctr2trace.py:85 |
kvi_status [M] | kvi_status (raw CSR 0x1e8) | M | cardctr2trace.py:86 |
stage busy % (perf window) [D] | one series per perf-window stage (% of cycles in the poll interval) | D | cardctr2trace.py:103-105 |
Counters do not carry args.src. The label is in the name (eagle4trace.py:103-106).
Flows (s + f with the same id, cat: "flow"):
seam HEAD->TAIL: from the HEAD EXPORT start to the TAIL ingest (xsim,xsim2trace.py:139).seam HEAD->TAIL (host relay): from the HEAD item end to the next TAIL item start (silicon,hostprof2trace.py:68).draft tree -> GPU verify: from the last join end to the TargetModelForward GPU start (hostprof2trace.py:74).
Process/thread metadata (ph: M, eagle4trace.py:114-132):
process_name: e.g."V80 HEAD card".process_sort_index: GPU 0, HOST 1, LINK 2, HEAD 3, TAIL 4, HEAD2 5, TAIL2 6.thread_name:"<diagram label> [<block id> · <clock>]".thread_sort_index: equal totid.
Minimal examples (taken from the shipped traces):
{"ph":"X","name":"G4 qkv GEMV","ts":6.924,"dur":54.091,"pid":10,"tid":5,"cat":"h_array","args":{"label":"D","src":"xsim FH_REF3 (full-HEAD BOOTSKIP, HX1 BD RTL) ITEMMON","block":"h_array","clock":"usr_1 132 MHz (2:1)","clock_mhz":132.0,"item":0,"level":0,"cycles":3570,"cycle_clock_mhz":66.0,"src_line":"xsim_FH_REF3_head.log:363"}}
{"ph":"X","name":"bubble: dependency stall (other HEAD stage busy)","ts":125.394,"dur":176.197,"pid":10,"tid":2,"cat":"bubble","args":{"label":"D","cause":"dependency stall (other HEAD stage busy)","block":"h_emb","bubble":true}}
{"ph":"i","s":"t","name":"step 52 start","ts":0.0,"pid":1,"tid":24,"args":{"label":"M","src":"box1 hostprof hostprof_P1HP_950437.json","step":52}}
{"ph":"C","name":"TREE serializer FIFO occupancy [M]","ts":722.411,"pid":20,"args":{"occupancy":1689,"capacity":16384,"survivors":2579}}
{"ph":"s","id":1,"name":"seam HEAD->TAIL","cat":"flow","ts":452.485,"pid":10,"tid":10}
{"ph":"f","bp":"e","id":1,"name":"seam HEAD->TAIL","cat":"flow","ts":488.424,"pid":20,"tid":12}
{"ph":"M","name":"process_name","pid":10,"args":{"name":"V80 HEAD card"}}
{"ph":"M","name":"thread_name","pid":10,"tid":2,"args":{"name":"G1 embedding gather [h_emb · usr_0 66 MHz]"}}
2. Collection methods
(a) xsim (cycle-level, any host with Vivado; no card)
- Producer. Full-HEAD BOOTSKIP TB
tb_e2e_opstream. The TB clock isclkwith 4 ns period (always #2,fullhead/tb_bs/tb_e2e_opstream.sv:155), and the array clock isclk_fast, 2 ns (:159). The monitors it uses:ITEMMONprints per-item cycles per top-FSM state (G1 G4 G5 G6 G7G G7U EMBG EXPORT INGEST WAIT …):fullhead/tb_bs/item_mon.sv:51.ROPEMON:fullhead/tb_bs/rope_mon.sv:8.KVWR:fullhead/tb_bs/kv_mon.sv:14.[PIPEOUT] AW#:fullhead/tb_bs/tb_e2e_opstream.sv:1911.- TAIL TB (
tailgate/cl4ref/tb/tb_e2e_opstream.sv,clk4 ns at:151):[RDONE] <stage>at:1758onward (e.g. g7p at:1764);[LVLTRACE] level_doneat:1276;[SERIALIZER]fromtailgate/cl4ref/src/layers/tree_cheap_serializer.sv:330.
All paths are under /shared/scratch/shape_generic/.
- Collect (example = the shipped trace):
- HEAD:
ARM=FH_REF3 SRCN=src_REF2 HP=8 STEP=run BSMODE=load BSDIR=... BUILD=... bash /shared/scratch/shape_generic/fullhead/run_arm_bs2.sh. The exact plusargs are infullhead/runs/FH_REF3/RUN.info. The log lands atfullhead/runs/FH_REF3/xsim.log. - TAIL:
bash /shared/scratch/shape_generic/tailgate/queue_cl4.sh, which runsarm_sg.sh cl4ref TGL_CL4REF2 -d E3_BEHAVand writestailgate/cl4ref/run_TGL_CL4REF2/try1/xsim.log.
- HEAD:
- Convert:
python3 xsim2trace.py --head <head xsim.log> --tail <tail xsim.log> --out traces/x.raw.json [--items 12]. - Time base and fidelity [D].
- TB-clock cycles = Δps / 1000 / 4 ns (
xsim2trace.py:69-71), then µs = cycles / MHz. HEAD uses 66 MHz (:78), TAIL 75 MHz (:120), both fromCLK_MHZ(eagle4trace.py:14). - ITEMMON counts are already TB-clock cycles, so the HEAD stage duration is
cycles / 66(xsim2trace.py:96-99). - HEAD time 0 is item 0's start, i.e. its ROPEMON time − (G1+G4) cycles (
:82). - TAIL time 0 is the end of the
osprey_session_init_tailop-log (:56). Its level is placed after HEAD item 2's EXPORT (:122). That placement is a layout choice, not a measured hand-off time. - Sim HBM is behavioural (
clk_hbm,fullhead/tb_bs/tb_e2e_opstream.sv:163), so HBM-bound stalls do not scale to silicon.
- TB-clock cycles = Δps / 1000 / 4 ns (
(b) Silicon host side (box1 only; HQ reads copies)
- Producer.
pair_hostprof.py, armed bysitecustomize.pywhenEAGLE4_HOSTPROF=1(pair_sitecustomize_run/sitecustomize.py:16-18). It is timing-only: it wraps calls withperf_counter_nsand changes nothing else. Switches (pair_hostprof.py:9-14):EAGLE4_HOSTPROF=1arms it.EAGLE4_HOSTPROF_OUT=<dir>is the output dir (default/mnt/data/eagle4_scratch/host_overhead,:48).EAGLE4_HOSTPROF_TAG=<tag>(:49).EAGLE4_HOSTPROF_CUDAEV=1adds CUDA-event pairs on GPU labels →gpu_ev, relative to a step-anchor event (:134-138,_resolve_gev:156).EAGLE4_HOSTPROF_LITE=1/EAGLE4_HOSTPROF_LEAVES=0give coarser, cheaper profiles.
The relay process ships its card stamps back when EAGLE4_HOSTPROF=1 (pair_card_server.py:129-131, :167). Card intervals are built in _card_busy (pair_hostprof.py:372).
Cited paths are the box1 reference copy under /shared/scratch/consolidated_hxf/cons_host/box1ref/R_scripts/. On box1 they live in the repo scripts/.
- Collect (box1's session only):
EXTRA_FPGA_ENV="EAGLE4_HOSTPROF=1 EAGLE4_HOSTPROF_CUDAEV=1 EAGLE4_HOSTPROF_TAG=<tag> EAGLE4_HOSTPROF_OUT=<dir>" MODE=fpga TAG=<tag> ... bash scripts/pair_sglang_run.sh.PYTHONPATHalready points atscripts/pair_sitecustomize_run(pair_sglang_run.sh:53-56), andEXTRA_FPGA_ENVis appended to the FPGA env (:63).- The JSON is written at process exit (
atexit,pair_hostprof.py:470) as<OUT>/hostprof_<TAG>_<pid>.json(:434). - The shipped example was collected by the CONS_HOST kit's lab script (
/sanctuary/pdi_inbox/CONS_HOST/v1.22tb2) and landed at/sanctuary/lab/results/2026-10-03/P1_HOSTPROF_62_61/hostprof_P1HP_950437.json. HQ's copy is in/shared/rnd_hq/from_box1/20260927/2026-10-03/P1_HOSTPROF_62_61/. - A profiled run's tok/s is not a speed number (the profiler costs about 0.1–0.15 ms/step,
pair_hostprof.pydocstring).
- Per-request jsonl.
pair_sglang_run.sh:99-100copies engine_test's output to<log>.perreq.jsonl. Each line hasprompt,output,time_spentandmeta_info(e2e_latency,spec_accept_length,completion_tokens,response_sent_to_client_ts, …).hostprof2trace.pydoes not read it today. It is the source for request-level spans if they are added. - Convert:
python3 hostprof2trace.py --json hostprof_<tag>_<pid>.json --out traces/x.raw.json --steps 52,53,54 --note "<context>". - Time base and fidelity [M].
- Host spans:
ev= [label, start ns from step start, dur ns], fromperf_counter_ns(CLOCK_MONOTONIC). - Steps are laid end to end: start = previous end +
gap_prev_ns(hostprof2trace.py:41). - GPU spans use the CUDA-event times
gpu_ev[3..4](ms from the step anchor), placed at step start +gpu_start_ms(:51-56). A CUDA pair measures stream time between two events, which can include GPU idle between kernels. - Card slices are
cards.head_iv/tail_iv(ns from step start, relay-stamped: item = doorbell → export seen, kvonly = bell → bell + kv_lat, commit = level-commit poll window;:57-62).
- Host spans:
(c) On-card counters (cardctr2trace.py, box1 only; HQ has not run it)
- Safety.
- BDFs come only from
EAGLE4_PAIR_HEAD_BDF/EAGLE4_PAIR_TAIL_BDF; it exits if one is unset (cardctr2trace.py:35-37,:116-117). - It refuses bus 0x41, i.e.
41:00.0(:41-43), and any device whose sysfs vendor:device is not0x10ee:0x50b4(:44-47). - BAR0 is opened
O_RDONLY|O_SYNCand mmappedPROT_READ, 4 KiB (:53-54). Only 32-bit loads, no writes exist in the script (:56-57).
- BDFs come only from
- Today: existing CSRs only. Per poll and per card it reads
CSR(:25-26) and OBS idx/data 0x160/0x164 (:27):- 0x19c pipe_lvl_count
- 0x1c4 pipe_status
- 0x1c8 boot_drop_cnt
- 0x1e8 kvi_status
- 0x168/0x16c satobs
- 0x170 tp_drop
- 0x174/0x178 fold
- 0x154 kv_res
- Collect + convert (one step, on box1):
EAGLE4_PAIR_HEAD_BDF=<head> EAGLE4_PAIR_TAIL_BDF=<tail> python3 cardctr2trace.py --out f.json --seconds 5 --period-us 200 [--perfwin] [--note ...]. - Sampling. Each poll reads HEAD then TAIL and timestamps each card's sample with
time.monotonic_ns()from the poll start (:60-74), then sleeps--period-us.- Each sample becomes counters (
:84-86). - Each time
pipe_lvl_countchanges, it closes alevel Nslice on h_lvlpipe / t_lvl (:87-95). Those slices are [M] ± one poll period. - One MMIO read measured 3.3–4.5 µs after AC4 [M], so a poll of about 12 reads costs about 50 µs per card [D].
- Each sample becomes counters (
- Proposed perf window 0x240–0x2BF (not in any bitstream; DESIGN.md).
- Reset: all counters 0 at card reset.
- PERF_CTL 0x240:
- bit0 enable;
- bit1 clear (write-1, self-clearing: zeroes all BUSY counters and the ring index);
- bit2 freeze (readable values hold while counting continues);
- [31:16] read-only free-running cycle-stamp high half.
- BUSY counters: 32-bit, wrap mod 2³², increment by 1 per cycle while the named state/handshake is active.
- Read with
--perfwin: word i ofPERF_HEAD/PERF_TAILat0x244 + 4*i(:28-32,:70-73):
| Card | Offset | Register |
|---|---|---|
| HEAD | 0x244 | G1 |
| HEAD | 0x248 | G4 |
| HEAD | 0x24c | G5 |
| HEAD | 0x250 | G6 |
| HEAD | 0x254 | G7G |
| HEAD | 0x258 | G7U |
| HEAD | 0x25c | EXPORT |
| HEAD | 0x260 | WAIT |
| HEAD | 0x264 | KVIFAN |
| HEAD | 0x268 / 0x26c | HBM_BYTES lo / hi |
| HEAD | 0x270 | URAM_RD |
| HEAD | 0x274 | DSP_BUSY |
| TAIL | 0x244 | INGEST |
| TAIL | 0x248 | G7P |
| TAIL | 0x24c | G9 |
| TAIL | 0x250 | G11 |
| TAIL | 0x254 | GLM |
| TAIL | 0x258 | G12 |
| TAIL | 0x25c | TREE |
| TAIL | 0x260 | G8 |
| TAIL | 0x264 | WAIT |
- Busy % =
((now − prev) & 0xFFFFFFFF) / (dt_us × f_MHz), with f = 66 (HEAD) / 75 (TAIL), excluding HBM words (:100-105). - Window absent: if every perf word reads
0xFFFFFFFFor0xDEADBEEF, the sample is skipped (:98-99). What an undecoded address actually returns on HX1 BD / TCLK75 is not verified. - Not read by the script yet: the timestamp ring (
0x278index,0x27cdata) and TAIL0x268SER_FIFO_PEAK.
3. Analysis step (analyze.py)
- Command:
python3 analyze.py <raw.json> <out.json> --kind xsim|hostprof|ac4 [--window name:t0_us:t1_us ...]. With no window it uses the whole trace (analyze.py:125-130).run_all.shhas the windows used for the shipped traces. - Busy / bubble.
bubbles()(eagle4trace.py:144-185) takes, per (pid, tid, block), the union ofXslices that are notbubbleinside the window. That union is busy; its complement in the window is gaps.- busy % = busy / span; bubble % = 100 − busy % [D].
- Cause taxonomy.
- hostprof / ac4 (
hostprof2trace.py:80-105): each gap is split into segments withattribute()(eagle4trace.py:188-204). A segment gets the first cause in the engine's list whose engines are active there:- cards: waiting on seam (other card), waiting on GPU, waiting on KV feed, waiting on host glue, in FPGA chain, not itemised (host in join);
- GPU: waiting on FPGA draft, waiting on KV feed, waiting on host glue;
- host / kvhost: waiting on GPU, waiting on cards, waiting on KV feed / host glue;
- else dependency / idle.
- xsim (
xsim2trace.py:151-163), whole gap:- waiting on seam / TAIL result when > 50 % of the gap overlaps a WAIT slice or TAIL work;
- otherwise dependency stall (other HEAD stage busy);
- TAIL: waiting on seam (HEAD busy) or dependency stall (other TAIL stage busy).
- hostprof / ac4 (
- What-if [P] (
analyze.py:94-104): gain = min(top-cause bubble, time in the window when only the cause's engines are busy) (exclusive(),:56-63, cause → engines map:21-33). what-if step = span − gain. It is an upper bound. - Outputs:
<out>.json= raw plusbubble: <cause>slices (one per segment) plusutil <track> [D]counters (:108-123).<out>.util.md= the per-window table.<out>.util.json={trace, kind, note, engines: [{window, span_us, engine, block, clock, busy_us, busy_pct, bubble_pct, n_gaps, top3: [[cause, us, pct_of_span] ×≤3], label:"D", whatif_step_us, whatif_gain_us, whatif_gain_pct, whatif_label:"P", gaps: [[t0,t1] ×≤40]}]}(:79-85,:97-106).
4. Producer API (eagle4trace.py)
from eagle4trace import Trace, TRACKS, PID, CLK_MHZ, SIM_CLK_NS, bubbles, attribute, overlap, clock_mhz
tr = Trace(title) # :75
tr.slice(track, name, ts_us, dur_us, label, src, proc=None, **args) # :89 ph X; args become args.*
tr.instant(track, name, ts_us, label, src, proc=None, **args) # :98 ph i (thread scope)
tr.counter(proc, name, ts_us, values: dict, label, src) # :103 ph C on process `proc` ("HEAD", ...)
tr.flow(track_a, ts_a, track_b, ts_b, name, proc_a=None, proc_b=None) # :108 ph s + f, auto id
doc = tr.write(path, extra=None) # :134 adds M metadata + otherData; returns the dict
bubbles(doc, window=None, cause_fn=None) -> {t0, t1, span_us, tracks:{(pid,tid,block): {busy_us, bubble_us, busy_pct, bubble_pct, gaps, segments, causes}}} # :144
attribute(g0, g1, evs, cands=[(cause, pred)], default="dependency / idle") -> [(a, b, cause)] # :188
- Track.
trackmust be a key ofTRACKS(eagle4trace.py:23-56). A new block needs a new entryname: (process, diagram block id, clock label), and thentidfollows automatically. - Label and source. Pass
labelas"M"/"D"/"P". Passsrcas a source description, and put a<file>:<line>insrc_line=when you have one. - Units. Times are in µs. For cycle-derived times pass
cycles=andcycle_clock_mhz=. - Waiting. Mark waiting (not work) with
bubble=True. - 4-card.
proc="HEAD2"/"TAIL2"re-homes a track onto the second card's process.
On-card counters
Today's bitstreams have no per-stage counters. Only level count, status and drop registers exist
(0x19c, 0x1c4, 0x1c8, 0x1e8, OBS ring 0x160/0x164). cardctr2trace.py polls them read-only on box1.
It is BDF-guarded, refuses 41:00.0, and only HQ's box1 session may run it. DESIGN.md proposes a perf window at
0x240–0x2BF: per-stage BUSY counters, HBM bytes, URAM reads, DSP-busy, and a 256-entry timestamp ring.
Estimated cost per card is about 1.5–3k LUT, about 1k FF and 1 BRAM18 P. With it, trace (a) can come from silicon.
Use it
- Pick a trace above and click download JSON for Perfetto. Or take
traces/*.jsonfrom/shared/rnd_hq/2026-10-06/tracks/eagle4_trace/. - Open ui.perfetto.dev, then Open trace file (or drag the file in). The trace stays in your browser.
- To make a new trace:
xsim2trace.py,hostprof2trace.pyorcardctr2trace.py, thenanalyze.py.run_all.shrebuilds everything.
Collection details: Collecting a trace. Sources: xsim FH_REF3 and TGL_CL4REF2 logs; box1 hostprof P1HP_950437 (10-03); box1 SIBXE_4CARD AC4 totals (10-06). Block ids come from the week-40 architecture diagram.