Class VkPhysicalDeviceIDProperties

  • All Implemented Interfaces:
    Pointer
    Direct Known Subclasses:
    VkPhysicalDeviceIDPropertiesKHR

    public class VkPhysicalDeviceIDProperties
    extends Struct
    Structure specifying IDs related to the physical device.
    Description

    deviceUUID must be immutable for a given device across instances, processes, driver APIs, driver versions, and system reboots.

    Applications can compare the driverUUID value across instance and process boundaries, and can make similar queries in external APIs to determine whether they are capable of sharing memory objects and resources using them with the device.

    deviceUUID and/or driverUUID must be used to determine whether a particular external object can be shared between driver components, where such a restriction exists as defined in the compatibility table for the particular object type:

    If deviceLUIDValid is FALSE, the contents of deviceLUID and deviceNodeMask are undefined. If deviceLUIDValid is TRUE and Vulkan is running on the Windows operating system, the contents of deviceLUID can be cast to an LUID object and must be equal to the locally unique identifier of a IDXGIAdapter1 object that corresponds to physicalDevice. If deviceLUIDValid is TRUE, deviceNodeMask must contain exactly one bit. If Vulkan is running on an operating system that supports the Direct3D 12 API and physicalDevice corresponds to an individual device in a linked device adapter, deviceNodeMask identifies the Direct3D 12 node corresponding to physicalDevice. Otherwise, deviceNodeMask must be 1.

    Note

    Although they have identical descriptions, VkPhysicalDeviceIDProperties::deviceUUID may differ from VkPhysicalDeviceProperties2::pipelineCacheUUID. The former is intended to identify and correlate devices across API and driver boundaries, while the latter is used to identify a compatible device and driver combination to use when serializing and de-serializing pipeline state.

    Note

    While VkPhysicalDeviceIDProperties::deviceUUID is specified to remain consistent across driver versions and system reboots, it is not intended to be usable as a serializable persistent identifier for a device. It may change when a device is physically added to, removed from, or moved to a different connector in a system while that system is powered down. Further, there is no reasonable way to verify with conformance testing that a given device retains the same UUID in a given system across all driver versions supported in that system. While implementations should make every effort to report consistent device UUIDs across driver versions, applications should avoid relying on the persistence of this value for uses other than identifying compatible devices for external object sharing purposes.

    Valid Usage (Implicit)

    Member documentation

    • sType – the type of this structure.
    • pNextNULL or a pointer to an extension-specific structure.
    • deviceUUID – an array of size UUID_SIZE, containing 8-bit values that represent a universally unique identifier for the device.
    • driverUUID – an array of size UUID_SIZE, containing 8-bit values that represent a universally unique identifier for the driver build in use by the device.
    • deviceLUID – an array of size LUID_SIZE, containing 8-bit values that represent a locally unique identifier for the device.
    • deviceNodeMask – a bitfield identifying the node within a linked device adapter corresponding to the device.
    • deviceLUIDValid – a boolean value that will be TRUE if deviceLUID contains a valid LUID and deviceNodeMask contains a valid node mask, and FALSE if they do not.

    Layout

    
     struct VkPhysicalDeviceIDProperties {
         VkStructureType sType;
         void * pNext;
         uint8_t deviceUUID[VK_UUID_SIZE];
         uint8_t driverUUID[VK_UUID_SIZE];
         uint8_t deviceLUID[VK_LUID_SIZE];
         uint32_t deviceNodeMask;
         VkBool32 deviceLUIDValid;
     }
    • Field Detail

      • SIZEOF

        The struct size in bytes.
      • ALIGNOF

        The struct alignment in bytes.
      • STYPE, PNEXT, DEVICEUUID, DRIVERUUID, DEVICELUID, DEVICENODEMASK, DEVICELUIDVALID

        The struct member offsets.
    • Constructor Detail

      • VkPhysicalDeviceIDProperties

        public VkPhysicalDeviceIDProperties​(java.nio.ByteBuffer container)
        Creates a VkPhysicalDeviceIDProperties instance at the current position of the specified ByteBuffer container. Changes to the buffer's content will be visible to the struct instance and vice versa.

        The created instance holds a strong reference to the container object.

    • Method Detail

      • sizeof

        public int sizeof()
        Description copied from class: Struct
        Returns sizeof(struct).
        Specified by:
        sizeof in class Struct
      • sType

        public int sType()
        Returns the value of the sType field.
      • pNext

        public long pNext()
        Returns the value of the pNext field.
      • deviceUUID

        public java.nio.ByteBuffer deviceUUID()
        Returns a ByteBuffer view of the deviceUUID field.
      • deviceUUID

        public byte deviceUUID​(int index)
        Returns the value at the specified index of the deviceUUID field.
      • driverUUID

        public java.nio.ByteBuffer driverUUID()
        Returns a ByteBuffer view of the driverUUID field.
      • driverUUID

        public byte driverUUID​(int index)
        Returns the value at the specified index of the driverUUID field.
      • deviceLUID

        public java.nio.ByteBuffer deviceLUID()
        Returns a ByteBuffer view of the deviceLUID field.
      • deviceLUID

        public byte deviceLUID​(int index)
        Returns the value at the specified index of the deviceLUID field.
      • deviceNodeMask

        public int deviceNodeMask()
        Returns the value of the deviceNodeMask field.
      • deviceLUIDValid

        public boolean deviceLUIDValid()
        Returns the value of the deviceLUIDValid field.
      • nsType

        public static int nsType​(long struct)
        Unsafe version of sType().
      • npNext

        public static long npNext​(long struct)
        Unsafe version of pNext().
      • ndeviceUUID

        public static java.nio.ByteBuffer ndeviceUUID​(long struct)
        Unsafe version of deviceUUID().
      • ndeviceUUID

        public static byte ndeviceUUID​(long struct,
                                       int index)
        Unsafe version of deviceUUID.
      • ndriverUUID

        public static java.nio.ByteBuffer ndriverUUID​(long struct)
        Unsafe version of driverUUID().
      • ndriverUUID

        public static byte ndriverUUID​(long struct,
                                       int index)
        Unsafe version of driverUUID.
      • ndeviceLUID

        public static java.nio.ByteBuffer ndeviceLUID​(long struct)
        Unsafe version of deviceLUID().
      • ndeviceLUID

        public static byte ndeviceLUID​(long struct,
                                       int index)
        Unsafe version of deviceLUID.
      • ndeviceNodeMask

        public static int ndeviceNodeMask​(long struct)
        Unsafe version of deviceNodeMask().
      • ndeviceLUIDValid

        public static int ndeviceLUIDValid​(long struct)
        Unsafe version of deviceLUIDValid().
      • nsType

        public static void nsType​(long struct,
                                  int value)
        Unsafe version of sType.
      • npNext

        public static void npNext​(long struct,
                                  long value)
        Unsafe version of pNext.