Rust API

let accepted = AcceptedWorldViewEvidence::from_gpu_execution_result(
    &provider,
    &epistemic_result,
    Vec::new(), // derive accepted assumptions from the GPU result
)?;

let exact = adapter.compile_and_evaluate_conditioned_source_with_accepted_world_view(
    probabilistic_source,
    &accepted,
)?;

let prepared = adapter.prepare_conditioned_source_with_accepted_world_view(
    probabilistic_source,
    &accepted,
)?;
let (updated, trace) = prepared.evaluate()?;

// Before: xlog-cuda 0.12.x
let mut recorder = LaunchRecorder::new_strict(stream_id);
recorder.read(&source).write(&destination);
recorder
    .preflight(runtime.as_ref())
    .expect("launch preflight");
stream
    .memcpy_dtod(&source, &mut destination)
    .expect("copy enqueue");
recorder
    .commit(runtime.as_ref())
    .expect("launch commit");

// After: xlog-cuda 0.13.0+; source and destination are tracked u32 slices.
let runtime = Arc::clone(
    provider
        .memory()
        .runtime()
        .expect("provider-owned CUDA runtime"),
);
let mut recorder = LaunchRecorder::new_strict(stream_id);
recorder.read(&source).write(&destination);
assert!(destination.len() >= source.len());

// SAFETY: every tracked allocation touched by the closure was recorded with
// its exact access, and the closure enqueues only on the supplied stream.
let enqueued = unsafe {
    recorder.enqueue(&runtime, |enqueue| {
        let result = cudarc::driver::sys::cuMemcpyDtoDAsync_v2(
            destination.device_ptr_value(),
            source.device_ptr_value(),
            source.len() * std::mem::size_of::<u32>(),
            enqueue.stream().cu_stream(),
        );
        if result == cudarc::driver::sys::cudaError_enum::CUDA_SUCCESS {
            Ok(())
        } else {
            Err(cudarc::driver::result::DriverError(result))
        }
    })
}
.expect("copy enqueue");
enqueued.commit().expect("launch commit");

// Construct: start from Default and override the fields you set.
let stats = ExecutionStats { ..Default::default() };

// Match: add a `..` arm so future fields do not break the pattern.
let ExecutionStats { total_duration_us, .. } = stats;

// Before: the reduced program came back directly.
let reduced = reduce_epistemic_program_to_ordinary(&program);

// After: propagate the error, or handle it.
let reduced = reduce_epistemic_program_to_ordinary(&program)?;

use std::sync::Arc;

// Construct: convert the vector into the shared slice.
let source = ChoiceSource {
    choices: Arc::from(pairs),          // pairs: Vec<(GroundAtom, f64)>
    choice_index,
    source_id,
};

// Mutate: build the full vector first, then share it — the field is no
// longer growable in place.
let mut pairs = Vec::new();
pairs.push((atom, p));
let choices: Arc<[(GroundAtom, f64)]> = Arc::from(pairs);