compiler_report

Julia

struct CompilerReport
CompilerReport(compiler::Symbol, rules::Vector{CompilerRuleRecord}, tally::Dict{Symbol, Int64})
CompilerReport(compiler, rules, tally)
CompilerReport(compiler::Symbol)

CompilerReport

What a build did, per rule. compiler_report returns one.

• compiler — the vocabulary value that built this problem.
• rules — a CompilerRuleRecord per equation / observed / setup array, in build order.
• tally — this build’s cascade counters (the per-build twin of the process-global _CASCADE_TALLY), for the counts a per-rule row does not carry: emitted kernels, class merges, subtree-table rescues.

tier_histogram(report) folds rules into tier → count, which is what show(::EsmProblem) prints.

Source

TypeScript

Not available in TypeScript. TypeScript is outside the simulation capability profile (Julia, Python, Rust): build an RHS and integrate it; TypeScript and Go are deliberately non-simulating.

Python

class CompilerReport
CompilerReport()
CompilerReport.add(entry: RuleTier) -> None
CompilerReport.entries: tuple[RuleTier, ...]  # property
CompilerReport.rules() -> tuple[str, ...]
CompilerReport.for_rule(rule: str) -> tuple[RuleTier, ...]
CompilerReport.tiers() -> dict[str, int]
CompilerReport.per_cell_rules() -> tuple[str, ...]
CompilerReport.__iter__() -> Iterator[RuleTier]
CompilerReport.__len__() -> int

Per rule, the tier it landed on and what declined on the way.

One entry per aggregate LANDING, not per rule: a rule whose body holds two aggregates, or whose aggregate is re-evaluated in a second phase, produces an entry each, which is what makes the record a cost story rather than a summary. A rule with no aggregate at all produces no entry — the whole ladder this records is the faq ladder — so rules is the rules that had a tier to land on.

Members

• add — Record a landing, ONCE per distinct (rule, phase, tier, chain).
• rules — Every rule that landed somewhere, in first-landing order.
• tiers — Landing counts by tier — the one-line cost summary.
• per_cell_rules — The rules that walked per cell. Empty under a build that survived native, by construction.

Source

Rust

pub struct CompilerReport {
    /* private fields */
}

impl CompilerReport { pub fn compiler(&self) -> Compiler }

impl CompilerReport { pub fn rules(&self) -> &[CompilerRuleReport] }

impl CompilerReport { pub fn n_taped(&self) -> usize }

impl CompilerReport { pub fn n_xla(&self) -> usize }

impl CompilerReport { pub fn n_oracle(&self) -> usize }

impl CompilerReport { pub fn n_vectorized(&self) -> usize }

impl CompilerReport { pub fn fused_groups(&self) -> usize }

impl CompilerReport { pub fn fused_instructions(&self) -> usize }

What built a Problem’s right-hand side, per rule (API_SPEC §5.8).

The names and their meanings are stable surface; the record’s exact shape is per-binding and is deliberately not pinned across the five.

Fusion is reported per PROGRAM, not per rule. The tape’s Step-4 fusion pass merges instructions across rule boundaries and the fused program keeps no rule attribution, so a tier of "taped" covers both a rule that runs as discrete instructions and one absorbed into a fused group; Self::fused_groups and Self::fused_instructions report the fusion at the level the tape actually tracks it.

Source · Rust docs

Go

Not available in Go. Go is outside the simulation capability profile (Julia, Python, Rust): build an RHS and integrate it; TypeScript and Go are deliberately non-simulating.