v1.162 (WIP):

HIGHLIGHTS: - added ability to create any number of queues of a specific type with custom priorities - queues must be explicitly specified in "DeviceCreationDesc" - queues in "DeviceCreationDesc" are organized into "QueueFamilyDesc" entries (a collection of queues of the same type) - compatibility & comfortable use is respected (read comments around changed functionality) - added supported "queueNum" (1 entry for each "QueueType") to "AdapterDesc" BREAKING CHANGES: - "CommandQueue" renamed to "Queue" (args and funcs) - deleted "HIGH_PRIORITY_COPY" (since priorities can be explicitly assigned) - "Architecture" moved to "AdapterDesc" (naturally better fits there) - deleted "isComputeQueueSupported" and "isCopyQueueSupported" (this info is available via "AdapterDesc" or even "GetQueue") - "SPIRVBindingOffsets" renamed to "VKBindingOffsets" - "DeviceCreationVKDesc::enabledExtensions" renamed to "DeviceCreationVKDesc::vkExtensions" (to match the style) DETAILS: - Core: added "queueIndex" to "GetQueue" - interface polishing (no additional changes) - lots of "correct this DeviceDesc!" work moved from implementations to "Creation.cpp" - code cleanup - updated docs
NVIDIAGameWorks · Jan 21, 2025 · 0b65be4 · 0b65be4
1 parent 84ed92d
commit 0b65be4
Show file tree

Hide file tree

Showing 92 changed files with 1,312 additions and 1,297 deletions.
diff --git a/Include/Extensions/NRIDeviceCreation.h b/Include/Extensions/NRIDeviceCreation.h
@@ -24,7 +24,7 @@ NriStruct(CallbackInterface) {
 };
 
 // Use largest offset for the resource type planned to be used as an unbounded array
-NriStruct(SPIRVBindingOffsets) {
+NriStruct(VKBindingOffsets) {
     uint32_t samplerOffset;
     uint32_t textureOffset;
     uint32_t constantBufferOffset;
@@ -38,16 +38,30 @@ NriStruct(VKExtensions) {
     uint32_t deviceExtensionNum;
 };
 
+NriStruct(QueueFamilyDesc) {
+    NriOptional const float* queuePriorities;   // [-1; 1]: low < 0, normal = 0, high > 0 ("queueNum" entries expected)
+    uint32_t queueNum;
+    Nri(QueueType) queueType;
+};
+
 NriStruct(DeviceCreationDesc) {
+    Nri(GraphicsAPI) graphicsAPI;
+    NriOptional Nri(Robustness) robustness;
     NriOptional const NriPtr(AdapterDesc) adapterDesc;
     NriOptional Nri(CallbackInterface) callbackInterface;
     NriOptional Nri(AllocationCallbacks) allocationCallbacks;
-    Nri(SPIRVBindingOffsets) spirvBindingOffsets;
-    NriOptional Nri(VKExtensions) vkExtensions;
-    Nri(GraphicsAPI) graphicsAPI;
-    NriOptional Nri(Robustness) robustness;
+
+    // 1 GRAPHICS queue is created by default
+    NriOptional const NriPtr(QueueFamilyDesc) queueFamilies;
+    NriOptional uint32_t queueFamilyNum;
+
+    // D3D specific
     NriOptional uint32_t shaderExtRegister;     // vendor specific shader extensions (default is NRI_SHADER_EXT_REGISTER, space is always "0")
 
+    // Vulkan specific
+    Nri(VKBindingOffsets) vkBindingOffsets;
+    NriOptional Nri(VKExtensions) vkExtensions;
+
     // Switches (disabled by default)
     bool enableNRIValidation;
     bool enableGraphicsAPIValidation;
@@ -59,7 +73,7 @@ NriStruct(DeviceCreationDesc) {
     bool disable3rdPartyAllocationCallbacks;    // to use "allocationCallbacks" only for NRI needs
 };
 
-// if "adapterDescs == NULL", then "adapterDescNum" gets set to the number of adapters
+// if "adapterDescs == NULL", then "adapterDescNum" is set to the number of adapters
 // else "adapterDescNum" must be set to number of elements in "adapterDescs"
 NRI_API Nri(Result) NRI_CALL nriEnumerateAdapters(NriPtr(AdapterDesc) adapterDescs, NonNriRef(uint32_t) adapterDescNum);
 

diff --git a/Include/Extensions/NRIHelper.h b/Include/Extensions/NRIHelper.h
@@ -70,11 +70,11 @@ NriStruct(HelperInterface) {
     Nri(Result) (NRI_CALL *AllocateAndBindMemory)       (NriRef(Device) device, const NriRef(ResourceGroupDesc) resourceGroupDesc, NriPtr(Memory)* allocations);
 
     // Populate resources with data (not for streaming!)
-    Nri(Result) (NRI_CALL *UploadData)                  (NriRef(CommandQueue) commandQueue, const NriPtr(TextureUploadDesc) textureUploadDescs, uint32_t textureUploadDescNum,
+    Nri(Result) (NRI_CALL *UploadData)                  (NriRef(Queue) queue, const NriPtr(TextureUploadDesc) textureUploadDescs, uint32_t textureUploadDescNum,
                                                             const NriPtr(BufferUploadDesc) bufferUploadDescs, uint32_t bufferUploadDescNum);
 
     // WFI
-    Nri(Result) (NRI_CALL *WaitForIdle)                 (NriRef(CommandQueue) commandQueue);
+    Nri(Result) (NRI_CALL *WaitForIdle)                 (NriRef(Queue) queue);
 
     // Information about video memory
     Nri(Result) (NRI_CALL *QueryVideoMemoryInfo)        (const NriRef(Device) device, Nri(MemoryLocation) memoryLocation, NriOut NriRef(VideoMemoryInfo) videoMemoryInfo);

diff --git a/Include/Extensions/NRILowLatency.h b/Include/Extensions/NRILowLatency.h
@@ -5,7 +5,7 @@
 NriNamespaceBegin
 
 NriForwardStruct(SwapChain);
-NriForwardStruct(CommandQueue);
+NriForwardStruct(Queue);
 
 // us = microseconds
 
@@ -50,7 +50,7 @@ NriStruct(LowLatencyInterface) {
     Nri(Result) (NRI_CALL   *GetLatencyReport)      (const NriRef(SwapChain) swapChain, NriOut NriRef(LatencyReport) latencyReport);
 
     // This function must be used in "low latency" mode instead of "QueueSubmit"
-    void        (NRI_CALL   *QueueSubmitTrackable)  (NriRef(CommandQueue) commandQueue, const NriRef(QueueSubmitDesc) queueSubmitDesc, const NriRef(SwapChain) swapChain);
+    void        (NRI_CALL   *QueueSubmitTrackable)  (NriRef(Queue) queue, const NriRef(QueueSubmitDesc) queueSubmitDesc, const NriRef(SwapChain) swapChain);
 };
 
 NriNamespaceEnd
diff --git a/Include/Extensions/NRIResourceAllocator.h b/Include/Extensions/NRIResourceAllocator.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "NRIRayTracing.h" // AccelerationStructureDesc
+#include "NRIRayTracing.h"
 
 // Convenient creation of resources, which get returned already bound to memory.
 // AMD Virtual Memory Allocator is used for memory allocations management:

diff --git a/Include/Extensions/NRISwapChain.h b/Include/Extensions/NRISwapChain.h
@@ -55,7 +55,7 @@ NriStruct(Window) {
 // queuedFrameNum = 2 - recommended if the GPU frame time is less than the desired frame time, but the sum of 2 frames is greater
 NriStruct(SwapChainDesc) {
     Nri(Window) window;
-    const NriPtr(CommandQueue) commandQueue;
+    const NriPtr(Queue) queue;
     Nri(Dim_t) width;
     Nri(Dim_t) height;
     uint8_t textureNum;

diff --git a/Include/Extensions/NRIWrapperD3D11.h b/Include/Extensions/NRIWrapperD3D11.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "NRIDeviceCreation.h" // CallbackInterface, AllocationCallbacks
+#include "NRIDeviceCreation.h"
 
 NonNriForwardStruct(AGSContext);
 NonNriForwardStruct(ID3D11Device);
@@ -14,8 +14,8 @@ NriNamespaceBegin
 NriStruct(DeviceCreationD3D11Desc) {
     ID3D11Device* d3d11Device;
     NriOptional AGSContext* agsContext;
-    Nri(CallbackInterface) callbackInterface;
-    Nri(AllocationCallbacks) allocationCallbacks;
+    NriOptional Nri(CallbackInterface) callbackInterface;
+    NriOptional Nri(AllocationCallbacks) allocationCallbacks;
     bool isNVAPILoaded; // at least NVAPI requires calling "NvAPI_Initialize" in DLL/EXE where the device is created in addition to NRI
 
     // Switches (disabled by default)

diff --git a/Include/Extensions/NRIWrapperD3D12.h b/Include/Extensions/NRIWrapperD3D12.h
@@ -2,13 +2,12 @@
 
 #pragma once
 
-#include "NRIDeviceCreation.h" // CallbackInterface, AllocationCallbacks
+#include "NRIDeviceCreation.h"
 
 NonNriForwardStruct(AGSContext);
 NonNriForwardStruct(ID3D12Heap);
 NonNriForwardStruct(ID3D12Device);
 NonNriForwardStruct(ID3D12Resource);
-NonNriForwardStruct(D3D12_HEAP_DESC);
 NonNriForwardStruct(ID3D12CommandQueue);
 NonNriForwardStruct(ID3D12DescriptorHeap);
 NonNriForwardStruct(ID3D12CommandAllocator);
@@ -18,14 +17,20 @@ NriNamespaceBegin
 
 NriForwardStruct(AccelerationStructure);
 
+// A collection of queues of the same type
+NriStruct(QueueFamilyD3D12Desc) {
+    NriOptional ID3D12CommandQueue* const* d3d12Queues; // if not provided, will be created
+    uint32_t queueNum;
+    Nri(QueueType) queueType;
+};
+
 NriStruct(DeviceCreationD3D12Desc) {
     ID3D12Device* d3d12Device;
-    ID3D12CommandQueue* d3d12GraphicsQueue;
-    ID3D12CommandQueue* d3d12ComputeQueue;
-    ID3D12CommandQueue* d3d12CopyQueue;
+    const NriPtr(QueueFamilyD3D12Desc) queueFamilies;
+    uint32_t queueFamilyNum;
     NriOptional AGSContext* agsContext;
-    Nri(CallbackInterface) callbackInterface;
-    Nri(AllocationCallbacks) allocationCallbacks;
+    NriOptional Nri(CallbackInterface) callbackInterface;
+    NriOptional Nri(AllocationCallbacks) allocationCallbacks;
     bool isNVAPILoaded; // at least NVAPI requires calling "NvAPI_Initialize" in DLL/EXE where the device is created in addition to NRI
 
     // Switches (disabled by default)

diff --git a/Include/Extensions/NRIWrapperVK.h b/Include/Extensions/NRIWrapperVK.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "NRIDeviceCreation.h" // CallbackInterface, AllocationCallbacks, SPIRVBindingOffsets, VKExtensions
+#include "NRIDeviceCreation.h"
 
 typedef void* VKHandle;
 typedef int32_t VKEnum;
@@ -13,37 +13,39 @@ NriNamespaceBegin
 
 NriForwardStruct(AccelerationStructure);
 
+// A collection of queues of the same type
+NriStruct(QueueFamilyVKDesc) {
+    NriOptional VKHandle* vkQueues; // if not provided, will be queried
+    uint32_t queueNum;
+    Nri(QueueType) queueType;
+    uint32_t familyIndex;
+};
+
 NriStruct(DeviceCreationVKDesc) {
-    Nri(CallbackInterface) callbackInterface;
-    Nri(AllocationCallbacks) allocationCallbacks;
-    Nri(SPIRVBindingOffsets) spirvBindingOffsets;
-    Nri(VKExtensions) enabledExtensions;
+    NriOptional Nri(CallbackInterface) callbackInterface;
+    NriOptional Nri(AllocationCallbacks) allocationCallbacks;
+    NriOptional const char* libraryPath;
+    Nri(VKBindingOffsets) vkBindingOffsets;
+    Nri(VKExtensions) vkExtensions; // enabled
     VKHandle vkInstance;
     VKHandle vkDevice;
     VKHandle vkPhysicalDevice;
-    const uint32_t* queueFamilyIndices;
-    uint32_t queueFamilyIndexNum;
-    const char* libraryPath;
+    const NriPtr(QueueFamilyVKDesc) queueFamilies;
+    uint32_t queueFamilyNum;
     uint8_t minorVersion; // >= 2
 
     // Switches (disabled by default)
     bool enableNRIValidation;
 };
 
-NriStruct(CommandQueueVKDesc) {
-    VKHandle vkQueue;
-    uint32_t queueFamilyIndex;
-    Nri(CommandQueueType) commandQueueType;
-};
-
 NriStruct(CommandAllocatorVKDesc) {
     VKNonDispatchableHandle vkCommandPool;
-    Nri(CommandQueueType) commandQueueType;
+    Nri(QueueType) queueType;
 };
 
 NriStruct(CommandBufferVKDesc) {
     VKHandle vkCommandBuffer;
-    Nri(CommandQueueType) commandQueueType;
+    Nri(QueueType) queueType;
 };
 
 NriStruct(DescriptorPoolVKDesc) {
@@ -91,7 +93,6 @@ NriStruct(AccelerationStructureVKDesc) {
 };
 
 NriStruct(WrapperVKInterface) {
-    Nri(Result) (NRI_CALL *CreateCommandQueueVK)            (NriRef(Device) device, const NriRef(CommandQueueVKDesc) commandQueueVKDesc, NriOut NriRef(CommandQueue*) commandQueue);
     Nri(Result) (NRI_CALL *CreateCommandAllocatorVK)        (NriRef(Device) device, const NriRef(CommandAllocatorVKDesc) commandAllocatorVKDesc, NriOut NriRef(CommandAllocator*) commandAllocator);
     Nri(Result) (NRI_CALL *CreateCommandBufferVK)           (NriRef(Device) device, const NriRef(CommandBufferVKDesc) commandBufferVKDesc, NriOut NriRef(CommandBuffer*) commandBuffer);
     Nri(Result) (NRI_CALL *CreateDescriptorPoolVK)          (NriRef(Device) device, const NriRef(DescriptorPoolVKDesc) descriptorPoolVKDesc, NriOut NriRef(DescriptorPool*) descriptorPool);
@@ -102,7 +103,7 @@ NriStruct(WrapperVKInterface) {
     Nri(Result) (NRI_CALL *CreateComputePipelineVK)         (NriRef(Device) device, VKNonDispatchableHandle vkPipeline, NriOut NriRef(Pipeline*) pipeline);
     Nri(Result) (NRI_CALL *CreateQueryPoolVK)               (NriRef(Device) device, const NriRef(QueryPoolVKDesc) queryPoolVKDesc, NriOut NriRef(QueryPool*) queryPool);
     Nri(Result) (NRI_CALL *CreateAccelerationStructureVK)   (NriRef(Device) device, const NriRef(AccelerationStructureVKDesc) accelerationStructureVKDesc, NriOut NriRef(AccelerationStructure*) accelerationStructure);
-    uint32_t    (NRI_CALL *GetCommandQueueFamilyIndexVK)    (const NriRef(CommandQueue) commandQueue);
+    uint32_t    (NRI_CALL *GetQueueFamilyIndexVK)           (const NriRef(Queue) queue);
     VKHandle    (NRI_CALL *GetPhysicalDeviceVK)             (const NriRef(Device) device);
     VKHandle    (NRI_CALL *GetInstanceVK)                   (const NriRef(Device) device);
     void*       (NRI_CALL *GetInstanceProcAddrVK)           (const NriRef(Device) device);

diff --git a/Include/NRI.h b/Include/NRI.h
@@ -25,8 +25,8 @@ Non-goals (exceptions apply to helper interfaces, where high-level abstraction a
 #pragma once
 
 #define NRI_VERSION_MAJOR 1
-#define NRI_VERSION_MINOR 161
-#define NRI_VERSION_DATE "13 January 2025"
+#define NRI_VERSION_MINOR 162
+#define NRI_VERSION_DATE "21 January 2025"
 
 #include "NRIDescs.h"
 
@@ -56,14 +56,15 @@ NriStruct(CoreInterface) {
     void                        (NRI_CALL *GetBufferMemoryDesc2)    (const NriRef(Device) device, const NriRef(BufferDesc) bufferDesc, Nri(MemoryLocation) memoryLocation, NriOut NriRef(MemoryDesc) memoryDesc); // requires "isGetMemoryDesc2Supported"
     void                        (NRI_CALL *GetTextureMemoryDesc2)   (const NriRef(Device) device, const NriRef(TextureDesc) textureDesc, Nri(MemoryLocation) memoryLocation, NriOut NriRef(MemoryDesc) memoryDesc); // requires "isGetMemoryDesc2Supported"
 
+    // Returns one of the pre-created queues (see "DeviceCreationDesc" or wrapper extensions). Return codes: UNSUPPORTED (no queues of "queueType") or INVALID_ARGUMENT (if "queueIndex" is out of bounds).
     // Getting COMPUTE and/or COPY queues switches VK "sharing mode" to "VK_SHARING_MODE_CONCURRENT", which can be slower on some HW. This approach is used to avoid
     // dealing with "queue ownership transitions", but also adds a requirement to "get" all async queues before resources creation participating into multi-queue activity
-    Nri(Result)         (NRI_CALL *GetCommandQueue)                 (NriRef(Device) device, Nri(CommandQueueType) commandQueueType, NriOut NriRef(CommandQueue*) commandQueue);
+    Nri(Result)         (NRI_CALL *GetQueue)                        (NriRef(Device) device, Nri(QueueType) queueType, uint32_t queueIndex, NriOut NriRef(Queue*) queue);
 
     // Create
     // "Creation" doesn't assume allocation of big chunks of memory on the device, but it happens for some entities implicitly
     // "Allocation" emphasizes the fact that there is a chunk of memory allocated under the hood
-    Nri(Result)         (NRI_CALL *CreateCommandAllocator)          (const NriRef(CommandQueue) commandQueue, NriOut NriRef(CommandAllocator*) commandAllocator);
+    Nri(Result)         (NRI_CALL *CreateCommandAllocator)          (const NriRef(Queue) queue, NriOut NriRef(CommandAllocator*) commandAllocator);
     Nri(Result)         (NRI_CALL *CreateCommandBuffer)             (NriRef(CommandAllocator) commandAllocator, NriOut NriRef(CommandBuffer*) commandBuffer);
     Nri(Result)         (NRI_CALL *CreateDescriptorPool)            (NriRef(Device) device, const NriRef(DescriptorPoolDesc) descriptorPoolDesc, NriOut NriRef(DescriptorPool*) descriptorPool);
     Nri(Result)         (NRI_CALL *CreateBuffer)                    (NriRef(Device) device, const NriRef(BufferDesc) bufferDesc, NriOut NriRef(Buffer*) buffer); // requires "BindBufferMemory"
@@ -195,15 +196,15 @@ NriStruct(CoreInterface) {
     Nri(Result)         (NRI_CALL *EndCommandBuffer)                (NriRef(CommandBuffer) commandBuffer);
 
     // Annotations for profiling tools: command queue - D3D11: NOP
-    void                (NRI_CALL *QueueBeginAnnotation)            (NriRef(CommandQueue) commandQueue, const char* name, uint32_t bgra);
-    void                (NRI_CALL *QueueEndAnnotation)              (NriRef(CommandQueue) commandQueue);
-    void                (NRI_CALL *QueueAnnotation)                 (NriRef(CommandQueue) commandQueue, const char* name, uint32_t bgra);
+    void                (NRI_CALL *QueueBeginAnnotation)            (NriRef(Queue) queue, const char* name, uint32_t bgra);
+    void                (NRI_CALL *QueueEndAnnotation)              (NriRef(Queue) queue);
+    void                (NRI_CALL *QueueAnnotation)                 (NriRef(Queue) queue, const char* name, uint32_t bgra);
 
     // Query
     void                (NRI_CALL *ResetQueries)                    (NriRef(QueryPool) queryPool, uint32_t offset, uint32_t num); // on host
 
     // Work submission and synchronization
-    void                (NRI_CALL *QueueSubmit)                     (NriRef(CommandQueue) commandQueue, const NriRef(QueueSubmitDesc) queueSubmitDesc); // to device
+    void                (NRI_CALL *QueueSubmit)                     (NriRef(Queue) queue, const NriRef(QueueSubmitDesc) queueSubmitDesc); // to device
     void                (NRI_CALL *Wait)                            (NriRef(Fence) fence, uint64_t value); // on host
     uint64_t            (NRI_CALL *GetFenceValue)                   (NriRef(Fence) fence);
 
@@ -219,7 +220,7 @@ NriStruct(CoreInterface) {
 
     // Native objects                                                                                            ___D3D11___________________________|_D3D12_______________________|_VK_________________________________
     void*               (NRI_CALL *GetDeviceNativeObject)           (const NriRef(Device) device);               // ID3D11Device*                   | ID3D12Device*               | VkDevice
-    void*               (NRI_CALL *GetCommandQueueNativeObject)     (const NriRef(CommandQueue) queue);          // -                               | ID3D12CommandQueue*         | VkQueue
+    void*               (NRI_CALL *GetQueueNativeObject)            (const NriRef(Queue) queue);                 // -                               | ID3D12CommandQueue*         | VkQueue
     void*               (NRI_CALL *GetCommandBufferNativeObject)    (const NriRef(CommandBuffer) commandBuffer); // ID3D11DeviceContext*            | ID3D12GraphicsCommandList*  | VkCommandBuffer
     uint64_t            (NRI_CALL *GetBufferNativeObject)           (const NriRef(Buffer) buffer);               // ID3D11Buffer*                   | ID3D12Resource*             | VkBuffer
     uint64_t            (NRI_CALL *GetTextureNativeObject)          (const NriRef(Texture) texture);             // ID3D11Resource*                 | ID3D12Resource*             | VkImage

diff --git a/Include/NRIDescs.h b/Include/NRIDescs.h
@@ -36,14 +36,14 @@ NriNamespaceBegin
 
 // Entities
 NriForwardStruct(Fence);
+NriForwardStruct(Queue);
 NriForwardStruct(Memory); // heap
 NriForwardStruct(Buffer);
 NriForwardStruct(Device);
 NriForwardStruct(Texture);
 NriForwardStruct(Pipeline);
 NriForwardStruct(QueryPool);
 NriForwardStruct(Descriptor);
-NriForwardStruct(CommandQueue);
 NriForwardStruct(CommandBuffer); // command list
 NriForwardStruct(DescriptorSet); // continuous set of descriptors in a descriptor heap
 NriForwardStruct(DescriptorPool); // descriptor heap
@@ -357,13 +357,6 @@ NriEnum(Robustness, uint8_t,
     D3D12       // moderate overhead, D3D12-level robust access (requires "VK_EXT_robustness2", soft fallback to VK mode)
 );
 
-NriEnum(CommandQueueType, uint8_t,
-    GRAPHICS,
-    COMPUTE,
-    COPY,
-    HIGH_PRIORITY_COPY
-);
-
 NriEnum(MemoryLocation, uint8_t,
     DEVICE,
     DEVICE_UPLOAD, // soft fallback to HOST_UPLOAD
@@ -1048,6 +1041,7 @@ NriStruct(ComputePipelineDesc) {
 #pragma region [ Barrier ]
 //============================================================================================================================================================================================
 
+// If AgilitySDK is not available, "UNKNOWN" will be silently mapped to "COMMON", leading to discrepancies with VK
 NriBits(AccessBits, uint16_t,                       // Compatible "StageBits" (including ALL):
     UNKNOWN                         = 0,
     INDEX_BUFFER                    = NriBit(0),    // INDEX_INPUT
@@ -1068,6 +1062,7 @@ NriBits(AccessBits, uint16_t,                       // Compatible "StageBits" (i
     SHADING_RATE_ATTACHMENT         = NriBit(15)    // FRAGMENT_SHADER
 );
 
+// Not used if "isEnchancedBarrierSupported" is "false", i.e. no AgilitySDK
 NriEnum(Layout, uint8_t,        // Compatible "AccessBits":
     UNKNOWN,
     COLOR_ATTACHMENT,           // COLOR_ATTACHMENT
@@ -1314,19 +1309,26 @@ NriEnum(Architecture, uint8_t,
     INTEGRATED // UMA
 );
 
+NriEnum(QueueType, uint8_t,
+    GRAPHICS,
+    COMPUTE,
+    COPY
+);
+
 NriStruct(AdapterDesc) {
     char name[256];
     uint64_t luid;
     uint64_t videoMemorySize;
     uint64_t sharedSystemMemorySize;
     uint32_t deviceId;
+    uint32_t queueNum[(uint32_t)NriScopedMember(QueueType, MAX_NUM)];
     Nri(Vendor) vendor;
+    Nri(Architecture) architecture;
 };
 
 NriStruct(DeviceDesc) {
     // Common
-    Nri(AdapterDesc) adapterDesc;
-    Nri(Architecture) architecture;
+    Nri(AdapterDesc) adapterDesc; // "queueNum" reflects available number of queues
     Nri(GraphicsAPI) graphicsAPI;
     uint16_t nriVersionMajor;
     uint16_t nriVersionMinor;
@@ -1493,8 +1495,6 @@ NriStruct(DeviceDesc) {
 
     // Features
     uint32_t isGetMemoryDesc2Supported : 1;             // D3D: always supported, VK: requires "maintenance4" support
-    uint32_t isComputeQueueSupported : 1;
-    uint32_t isCopyQueueSupported : 1;
     uint32_t isTextureFilterMinMaxSupported : 1;
     uint32_t isLogicFuncSupported : 1;
     uint32_t isDepthBoundsTestSupported : 1;