Guides

Reading results

Every number Cascade shows comes from Accel-Sim's own output. Sims send raw stdout, and the app parses one stats block per finished kernel out of it.

Metrics on a sim card#

Each sim card shows its latest totals. They update every time the sim sends a log chunk with a new kernel block.

metric	Accel-Sim line	meaning
Cycles	`gpu_tot_sim_cycle`	Simulated GPU cycles so far, over every finished kernel.
IPC	`gpu_tot_ipc`	Instructions per cycle over the whole simulated GPU so far.
Sim rate	`gpgpu_simulation_rate`	How fast the simulator itself runs, in simulated instructions per wall-clock second.
Kernels	`kernel_name` blocks	Kernel blocks parsed so far, out of the trace's kernel count.

In the examples on these pages, one sim finished with gpu_tot_sim_cycle 76713, gpu_tot_ipc 346.2289 and a sim rate of 510774 instructions per second. Those numbers come from the recorded BabelStream log that the stand-in simulator replays.

Simulated time per kernel#

Accel-Sim counts cycles. To turn cycles into time, the app divides by the config's core clock, the first value of -gpgpu_clock_domains in its gpgpusim.config.

text

sim_time_ns = gpu_sim_cycle / core_clock_mhz * 1000

For example, the first kernel in the captured run took 6174 cycles on SM86_RTX3070, whose core clock is 1132 MHz, so its sim_time_ns is 6174 / 1132 * 1000 = 5454.06.

Real against simulated#

The comparison panel lines kernels up by position. Row i is the ith kernel the sims finished, and for each config it shows the median sim_time_ns over that config's replicas. With several replicas, one odd sim can't skew the row.

When a trace has real timings from the original GPU, row i also shows the ith real kernel by kernel_id, and the panel shows each config's relative error per kernel and its mean absolute error over all kernels. The app reads them from real_timing.json in the trace, or the file metadata.json names in real_timing, as a list of {kernel_id, kernel_name, duration_ns, grid, block}.

The profiler doesn't capture real timings yet. Until it does, has_real_timing is false, real_ns is null on every row, and the panel shows simulated time only.

Outputs#

A simulator can upload the files it writes. cascade worker uploads every file Accel-Sim created or changed in its run directory, such as kernel-stats.csv, gpgpu_inst_stats.txt and exit-status.txt, and then its own log as accelsim.log.gz. It does this when the simulator exits, succeeded or failed, before the final heartbeat. A cancelled sim uploads nothing.

The run screen's Outputs card groups the files by config, then by replica, with each file's size. Select a sim card, and its panel lists the same sim's files under Files. Every file has a download button. A .csv, .txt or .log file up to 16 MiB, gzipped or not, also has a preview button that shows its first 200 lines.

The card has two more buttons. Perfetto JSON downloads the run's Perfetto trace. Open in Perfetto opens ui.perfetto.dev in a new tab and hands it the same trace, so there is no file to save and open. Both stay disabled until a sim has finished a kernel.

In the examples on these pages, each sim's output files come from a recorded OPT-125m run on SM90_H100, which the stand-in copies in with --replay-outputs. They don't match the BabelStream log the sim replays.

The Perfetto trace#

The app builds the trace from the kernel stats it parsed, so every run has one, whether or not the simulator wrote its own. It is a Chrome trace JSON file.

Each config is one process, named <config> · Accel-Sim simulated GPU.
Each replica is one thread in its config's process, named replica <n> · <sim id>.
Each finished kernel is one slice, named k<uid> <readable name>, such as k2 copy_kernel. The readable name is the one the run screen shows.
A sim's slices are laid end to end in kernel order. A slice lasts the kernel's sim_time_ns, and the time axis is simulated microseconds. A kernel without sim_time_ns is left out.
Each slice's args hold kernel_name as recorded, kernel_index, uid, gpu_sim_cycle, gpu_sim_insn, ipc and sim_time_ns. start_cycle and end_cycle count the sim's cycles before and after the kernel.
When the trace has real timing, one more process, Real hardware · <source_gpu>, holds the measured kernels the same way.

Each slice includes the config's launch latency. Laying kernels end to end leaves out host time, copies and any overlap between kernels.

Downloads#

download	where	contents
Run results	Download results on the run screen, or the API	One `RunResults` JSON file: the run, the trace, every sim's per-kernel stats, and the comparison.
Sim results	Results on a sim card, or the API	One `SimResults` file: the sim, its config, its kernels and its totals.
Log	Log on a sim card, or the API	The sim's full raw output, as plain text.
Output file	The Outputs card, Files in a sim's panel, or the API	One file as the sim uploaded it. A `.gz` file stays compressed.
Perfetto JSON	Perfetto JSON on the Outputs card, or the API	The run's simulated kernels as a Chrome trace JSON, named `<run_id>-perfetto.json`.

Each kernel in a results file has a stats map with every key = value line in its Accel-Sim block, about 950 keys and 30 KB per kernel. Numbers are parsed as floats, and anything else stays a string. The live run screen leaves stats out to stay small. Use the downloads for it.

How the parser reads a log#

A kernel's block starts at a kernel_name = ... line and ends at the next gpgpu_simulation_time, launching kernel name:, Processing kernel, Header info loaded or GPGPU-Sim: *** exit detected line, or at the next kernel_name. A block still open when the sim finishes is closed then. The launching kernel name: X uid: N line sets the sim's current_kernel.

The app stores the raw log as well as the parsed stats. After a restart, it rebuilds a running sim's parser by replaying that sim's stored log, so parsing picks up where it stopped.