Struct Device 

pub struct Device {
    pub device: DeviceSpec,
    pub allocator: Arc<dyn Allocator>,
    pub compilers: Vec<CompilerPair>,
    pub renderer: Arc<dyn Renderer>,
    pub compiler: Arc<dyn Compiler>,
    pub runtime: RuntimeFactory,
}

A device that owns renderer, compiler, runtime, and allocator.

This follows Tinygrad’s architecture where a Device is a complete compilation + execution unit for a specific backend.

Example

let cpu_device = create_cpu_device()?;
let spec = cpu_device.renderer.render(&kernel_ast, Some("E_L3"))?;
let compiled = cpu_device.compiler.compile(&spec)?;
let program = (cpu_device.runtime)(&compiled)?;
unsafe { program.execute(&buffers, &vals, None, None)?; }

Fields

device: DeviceSpec

Device specification

allocator: Arc<dyn Allocator>

Memory allocator for this device

compilers: Vec<CompilerPair>

Available (renderer, compiler) pairs for this device

Most devices have one pair, but some may have multiple (e.g., different optimization levels or compilation modes).

renderer: Arc<dyn Renderer>

Primary renderer for this device

This is typically compilers[0].0, stored separately for convenience.

compiler: Arc<dyn Compiler>

Primary compiler for this device

This is typically compilers[0].1, stored separately for convenience.

runtime: RuntimeFactory

Runtime factory for creating executable programs

Takes (entry_point, compiled_bytes) and returns a Program.

Implementations

impl Device

pub fn new( device: DeviceSpec, allocator: Arc<dyn Allocator>, renderer: Arc<dyn Renderer>, compiler: Arc<dyn Compiler>, runtime: RuntimeFactory, ) -> Self

Create a new device with a single compiler pair.

This is a convenience constructor for the common case where a device has only one renderer/compiler combination.

pub fn base_device_key(&self) -> &'static str

Get the base device key (strips device ID).

Used for compiled byte cache sharing across device instances. Examples:

• DeviceSpec::Cpu -> “CPU”
• DeviceSpec::Cuda { device_id: 0 } -> “CUDA”
• DeviceSpec::Cuda { device_id: 1 } -> “CUDA”
• DeviceSpec::Metal { device_id: 0 } -> “Metal”

This allows compiled CUDA kernels to be reused across CUDA:0 and CUDA:1.