Struct ExecutionContext 

pub struct ExecutionContext { /* private fields */ }

Execution context for NPU operations.

Implementations

impl ExecutionContext

pub fn new(device: Arc<NpuDevice>) -> Self

Create a new execution context.

Examples found in repository

examples/full_inference_pipeline.rs (line 155)

fn execute_inference() {
    println!("4. Inference Execution");

    let device = Arc::new(NpuDevice::new());
    match device.initialize() {
        Ok(_) => {
            let ctx = ExecutionContext::new(device);
            
            let input = Tensor::random(&[1, 224, 224, 3]);
            let weights = Tensor::random(&[1, 1, 3, 64]);

            println!("   Input: {:?}", input.shape());
            println!("   Weights: {:?}", weights.shape());

            match ctx.execute_conv1x1(&input.data, &weights.data) {
                Ok(output) => {
                    println!("   ✓ Conv1x1 executed");
                    println!("   Output: {:?}", output.shape());
                    println!("   Throughput: {:.4} GOPS\n", ctx.get_current_throughput_gops());
                }
                Err(e) => println!("   ✗ Execution failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Device init failed: {}\n", e),
    }
}

pub fn execute_matmul( &self, a: &ArrayD<f32>, b: &ArrayD<f32>, ) -> Result<ArrayD<f32>>

Execute matrix multiplication operation.

pub fn execute_batched_matmul( &self, a: &ArrayD<f32>, b: &ArrayD<f32>, ) -> Result<ArrayD<f32>>

Execute batched matrix multiplication.

pub fn execute_conv1x1( &self, input: &ArrayD<f32>, kernel: &ArrayD<f32>, ) -> Result<ArrayD<f32>>

Execute 1x1 convolution.

Examples found in repository

examples/full_inference_pipeline.rs (line 163)

fn execute_inference() {
    println!("4. Inference Execution");

    let device = Arc::new(NpuDevice::new());
    match device.initialize() {
        Ok(_) => {
            let ctx = ExecutionContext::new(device);
            
            let input = Tensor::random(&[1, 224, 224, 3]);
            let weights = Tensor::random(&[1, 1, 3, 64]);

            println!("   Input: {:?}", input.shape());
            println!("   Weights: {:?}", weights.shape());

            match ctx.execute_conv1x1(&input.data, &weights.data) {
                Ok(output) => {
                    println!("   ✓ Conv1x1 executed");
                    println!("   Output: {:?}", output.shape());
                    println!("   Throughput: {:.4} GOPS\n", ctx.get_current_throughput_gops());
                }
                Err(e) => println!("   ✗ Execution failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Device init failed: {}\n", e),
    }
}

pub fn get_current_throughput_gops(&self) -> f64

Get current throughput in GOPS.

Examples found in repository

examples/full_inference_pipeline.rs (line 167)

fn execute_inference() {
    println!("4. Inference Execution");

    let device = Arc::new(NpuDevice::new());
    match device.initialize() {
        Ok(_) => {
            let ctx = ExecutionContext::new(device);
            
            let input = Tensor::random(&[1, 224, 224, 3]);
            let weights = Tensor::random(&[1, 1, 3, 64]);

            println!("   Input: {:?}", input.shape());
            println!("   Weights: {:?}", weights.shape());

            match ctx.execute_conv1x1(&input.data, &weights.data) {
                Ok(output) => {
                    println!("   ✓ Conv1x1 executed");
                    println!("   Output: {:?}", output.shape());
                    println!("   Throughput: {:.4} GOPS\n", ctx.get_current_throughput_gops());
                }
                Err(e) => println!("   ✗ Execution failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Device init failed: {}\n", e),
    }
}

pub fn get_metrics(&self) -> PerformanceMetrics

Get performance metrics.

pub fn get_device(&self) -> Arc<NpuDevice>

Get underlying device.