Struct GpuId 

pub struct GpuId {
    pub permanent: PermanentGpuId,
    pub session: Option<SessionGpuId>,
}

The identity of an adapter, for GpuPreference::Device.

It is two facts, not one. permanent is what a config stores and what should still name the same hardware after a restart; session is what the backend can match in this process. A per-process handle (a LUID, a Metal registry id, a DRM node) does not survive a reboot, and a PCI pair does not distinguish two identical cards — so neither alone is a complete identity.

The permanent part is serialised; the session is not, because a config cannot know it.

Fields

permanent: PermanentGpuId

What survives a restart, where the platform has anything that does.

session: Option<SessionGpuId>

The backend’s handle for this adapter in this process. None for a stored id.

Implementations

impl GpuId

pub const fn by_device(device_id: u32) -> GpuId

A GpuId matched on the PCI device id alone, with no session.

This is what ZED_DEVICE_ID lowers to: the variable names a device only, so the vendor is left open and the permanent part is the whole preference.

pub const fn pci(vendor_id: u32, device_id: u32) -> GpuId

The permanent and session identity of a PCI adapter.

pub const fn single() -> GpuId

The identity of the one adapter on a single-GPU platform.

pub fn matches(&self, adapter: &GpuAdapterInfo) -> bool

Whether adapter is the one this id names.

A session is the stronger claim: when it is present, only the adapter with that session matches. Without one — a config, or a caller that knows only the model — the permanent part decides, and two identical cards both match.

pub fn parse_pci_id(value: &str) -> Option<u32>

Parse a four-hex-digit PCI device id, such as a debug override carries.

The id is hexadecimal; a decimal-looking value such as 6422 parses as the hex 0x6422, matches nothing, and silently falls through to the default adapter.

Trait Implementations

impl Clone for GpuId

fn clone(&self) -> GpuId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GpuId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GpuId

fn deserialize<__D>( __deserializer: __D, ) -> Result<GpuId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for GpuId

impl PartialEq for GpuId

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for GpuId

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GpuId