Struct CompileReport 

pub struct CompileReport { /* private fields */ }

Structured evidence tied to the exact compiler which produced it.

Implementations

impl CompileReport

pub fn guidance(&self) -> Result<ReportGuidance>

Suggest residency and LDS layout experiments using producer-supplied thresholds. Unavailable evidence and unvalidated bank models yield no recommendations. All joint residency limits must be captured.

impl CompileReport

pub fn validate(&self) -> Result<()>

Reject unrecognized evidence instead of interpreting a different schema.

pub fn compiler_identity(&self) -> &str

Content digest of the producing compiler library.

pub fn target(&self) -> &str

Exact device profile used to specialize the source.

pub fn processor_mode(&self) -> ProcessorMode

Requested AMDGPU execution policy.

pub fn json(&self) -> &Value

Original versioned JSON, including evidence not represented by accessors.

Examples found in repository

examples/patch_bench.rs (line 318)

fn prepare(
    stream: &mut Stream,
    compiler: &Compiler,
    case: &Case,
    shared: Option<std::sync::Arc<Vec<Buffer>>>,
) -> Result<Arm> {
    let artifact = compiler.module(case.source).compile(&case.spec)?;
    let kernel = unsafe { stream.load_artifact(&artifact) }?;
    let constants = Constants::indices(&kernel, &case.indices)?;
    let buffers = if let Some(buffers) = shared {
        buffers
    } else {
        std::sync::Arc::new(
            case.data
                .iter()
                .map(|data| {
                    let buffer = stream.allocate(data.len())?;
                    stream.upload_blocking(buffer.binding(), data)?;
                    Ok(buffer)
                })
                .collect::<Result<Vec<_>>>()?,
        )
    };
    let bindings: Vec<_> = buffers.iter().map(Buffer::binding).collect();
    let mut graph = stream.graph()?;
    let mut prior = None;
    for _ in 0..32 {
        prior = Some(unsafe {
            graph.dispatch(
                prior.as_slice(),
                &kernel,
                case.grid,
                case.block,
                &constants,
                &bindings,
            )
        }?);
    }
    let identity = serde_json::json!({"compiler":artifact.compiler_identity(), "artifact":hrx::bundle::digest(artifact.bytes()),
        "report":artifact.report().map(|report| report.json())});
    Ok(Arm {
        graph: graph.finish()?,
        buffers,
        identity,
    })
}

pub fn expansions(&self) -> Result<Option<Vec<Expansion>>>

Per-selection lowering expansion, available in summary and detailed reports. Missing collection is distinct from an empty collection.

pub fn entries(&self) -> Result<Vec<EntryResources>>

Resource summaries, preserving unknown values rather than reporting zero.

pub fn wait_reasons(&self) -> Result<Option<Vec<WaitReason>>>

Wait explanations from detailed reports. None means this evidence was not collected; Some([]) means it was collected with no wait rows.

pub fn wait_reason_changes( &self, after: &Self, ) -> Result<Option<Vec<WaitReasonChange>>>

Compare wait reasons by semantic identity. None means at least one report lacks wait evidence; an empty vector means both collected no rows. Added/removed reasons have null deltas, never invented zero counts.

pub fn changes(&self, after: &Self) -> Result<Vec<EntryChange>>

Compare named entries after checking compiler, schema and target identity. Added/removed entries are explicit; unknown analysis is never treated as zero.

pub fn ensure_comparable(&self, other: &Self) -> Result<()>

Check the minimum identity contract for comparing compiler evidence. Source and configuration may differ: those are the experiment variables.

Trait Implementations

impl Clone for CompileReport

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompileReport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompileReport

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CompileReport

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.