Struct DeviceProperties 

pub struct DeviceProperties {
    pub features: Features,
    pub memory: MemoryDeviceProperties,
    pub hardware: HardwareProperties,
    pub timing_method: TimingMethod,
    pub identity: DeviceIdentity,
}

Properties of what the device can do, like what Feature are supported by it and what its memory properties are.

Fields

features: Features

The features supported by the runtime.

memory: MemoryDeviceProperties

The memory properties of this client.

hardware: HardwareProperties

The topology properties of this client.

timing_method: TimingMethod

The method used for profiling on the device.

identity: DeviceIdentity

Who the device is, and what its kernels are keyed to.

Implementations

impl DeviceProperties

pub fn new( features: Features, memory_props: MemoryDeviceProperties, hardware: HardwareProperties, timing_method: TimingMethod, identity: DeviceIdentity, ) -> Self

Create a new feature set with the given features and memory properties.

identity is a required argument rather than something a backend may fill in afterwards, so a runtime cannot ship reporting an anonymous device — the failure mode that leaves a bundle unable to say what it was built for.

pub fn type_usage(&self, ty: StorageType) -> EnumSet<TypeUsage>

Get the usages for a type

pub fn atomic_type_usage(&self, ty: Type) -> EnumSet<AtomicUsage>

Get the usages for an atomic type

pub fn supports_type(&self, ty: impl Into<Type>) -> bool

Whether the type is supported in any way

pub fn supports_address(&self, ty: impl Into<AddressType>) -> bool

Whether the address type is supported in any way

pub fn register_address_type(&mut self, ty: impl Into<AddressType>)

Register an address type to the features

pub fn register_atomic_type_usage( &mut self, ty: Type, uses: impl Into<EnumSet<AtomicUsage>>, )

Register an address type to the features

pub fn register_type_usage( &mut self, ty: impl Into<StorageType>, uses: impl Into<EnumSet<TypeUsage>>, )

Register a storage type to the features

pub fn register_semantic_type(&mut self, ty: SemanticType)

Register a semantic type to the features

pub fn register_opaque_type(&mut self, ty: OpaqueType)

Register an opaque type to the features

pub fn checksum(&self) -> u64

Create a stable hash of all device properties relevant to kernel compilation. Can be used as a stable checksum for a compilation cache.

Trait Implementations

impl Clone for DeviceProperties

fn clone(&self) -> DeviceProperties

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceProperties

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

Formats the value using the given formatter.

impl Eq for DeviceProperties

impl PartialEq for DeviceProperties

fn eq(&self, other: &DeviceProperties) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DeviceProperties

impl TypeHash for DeviceProperties

fn write_hash(_hasher: &mut impl Hasher)

Write the structure of the type to the hasher

fn type_hash() -> u64

Generate a stable hash of the type structure.