Enum CompiledGraph

pub enum CompiledGraph<S: Shape, T: DType, D: Dev> {
    Cpu {
        order: Vec<usize>,
        graph: Vec<GraphNode<T>>,
        ghost: PhantomData<(S, T, D)>,
    },
}

A representation of the compiled graph. The shape is the output shape.

Variants

Cpu

Fields

order: Vec<usize>

graph: Vec<GraphNode<T>>

ghost: PhantomData<(S, T, D)>

Implementations

impl<S: Shape, T: DType, D: Dev> CompiledGraph<S, T, D>

pub fn run(&self) -> Result<Tensor<S, T, D>>

Run the precompiled graph. This executes all nodes on the specified backend device and returns a concrete tensor.

Examples found in repository

examples/hello_world/main.rs (line 18)

fn main() {
    let mut graph: Graph<f32> = Graph::empty();
    let _arange = GraphTensor::<R1<10>, f32, Cpu>::arange(&mut graph, 0., 1.);
    let a = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 1.0);
    let b = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 2.0);
    let c = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 3.0);
    let d = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 4.0);
    let res = a * b + c;
    let _out = res + d;

    graph.optimize();

    graph.visualize("graph.png").unwrap();

    let compiled: constensor_core::CompiledGraph<R2<3, 4>, f32, Cpu> = graph.compile().unwrap();
    let res = compiled.run().unwrap();

    let tensor: Tensor<R2<3, 4>, f32, Cpu> = res;

    assert_eq!(tensor.data().unwrap().to_vec(), vec![vec![9.0; 4]; 3],);
}

examples/matmul/main.rs (line 27)

fn bench<T: DType, const B: usize, const M: usize, const K: usize, const N: usize>(
    type_name: &str,
    alpha: T,
    beta: T,
) {
    // Number of times to run the matmul for averaging
    let iterations = 1;
    let mut total = std::time::Duration::new(0, 0);

    let mut graph = Graph::empty();
    let a = GraphTensor::<R3<B, M, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(1.));
    // Strided matmuls works on all devices.
    let b = GraphTensor::<R3<B, N, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.)).t();
    // let b = GraphTensor::<R3<B, K, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.));
    let o = GraphTensor::<R3<B, M, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(3.));
    let _c = a.matmul_axpby(b, o, alpha, beta);

    graph.optimize();
    let compiled: CompiledGraph<R3<B, M, N>, T, BestDevice<0>> = graph.compile().unwrap();

    for _ in 0..iterations {
        let start = Instant::now();

        let tensor = std::hint::black_box(compiled.run().unwrap());
        dbg!(tensor.data().unwrap());

        total += start.elapsed();
    }

    let avg = total / (iterations as u32);
    println!("Average execution time for {type_name} over {iterations} iterations: {avg:?}");
}