Data graphs

Data graph pipelines encapsulate computational graphs that operate on whole resources (e.g. tensors). The graph operations that form these computational graphs are executed by graph processing engines.

Pipeline Creation

To create data graph pipelines, call:

// Provided by VK_ARM_data_graph
VkResult vkCreateDataGraphPipelinesARM(
    VkDevice                                    device,
    VkDeferredOperationKHR                      deferredOperation,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkDataGraphPipelineCreateInfoARM*     pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

  • device is the logical device that creates the data graph pipelines.

  • deferredOperation is VK_NULL_HANDLE or the handle of a valid VkDeferredOperationKHR request deferral object for this command.

  • pipelineCache is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.

  • createInfoCount is the length of the pCreateInfos and pPipelines arrays.

  • pCreateInfos is a pointer to an array of VkDataGraphPipelineCreateInfoARM structures.

  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

  • pPipelines is a pointer to an array of VkPipeline handles in which the resulting data graph pipelines objects are returned.

The implementation will create a pipeline in each element of pPipelines from the corresponding element of pCreateInfos. If the creation of any pipeline fails, that pipeline will be set to VK_NULL_HANDLE.

Valid Usage

  • VUID-vkCreateDataGraphPipelinesARM-dataGraph-09760
    The dataGraph feature must be enabled

  • VUID-vkCreateDataGraphPipelinesARM-device-09927
    device must support at least one queue family with the VK_QUEUE_DATA_GRAPH_BIT_ARM capability

  • VUID-vkCreateDataGraphPipelinesARM-deferredOperation-09761
    deferredOperation must be VK_NULL_HANDLE

  • VUID-vkCreateDataGraphPipelinesARM-deferredOperation-09916
    If deferredOperation is not VK_NULL_HANDLE, the flags member of elements of pCreateInfos must not include VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT

  • VUID-vkCreateDataGraphPipelinesARM-pNext-09928
    If at least one of the VkDataGraphPipelineCreateInfoARM includes a VkDataGraphPipelineIdentifierCreateInfoARM structure in its pNext chain then pipelineCache must not be VK_NULL_HANDLE

  • VUID-vkCreateDataGraphPipelinesARM-pipelineCache-09762
    If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized

Valid Usage (Implicit)

  • VUID-vkCreateDataGraphPipelinesARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkCreateDataGraphPipelinesARM-deferredOperation-parameter
    If deferredOperation is not VK_NULL_HANDLE, deferredOperation must be a valid VkDeferredOperationKHR handle

  • VUID-vkCreateDataGraphPipelinesARM-pipelineCache-parameter
    If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle

  • VUID-vkCreateDataGraphPipelinesARM-pCreateInfos-parameter
    pCreateInfos must be a valid pointer to an array of createInfoCount valid VkDataGraphPipelineCreateInfoARM structures

  • VUID-vkCreateDataGraphPipelinesARM-pAllocator-parameter
    If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

  • VUID-vkCreateDataGraphPipelinesARM-pPipelines-parameter
    pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles

  • VUID-vkCreateDataGraphPipelinesARM-device-queuecount
    The device must have been created with at least 1 queue

  • VUID-vkCreateDataGraphPipelinesARM-createInfoCount-arraylength
    createInfoCount must be greater than 0

  • VUID-vkCreateDataGraphPipelinesARM-deferredOperation-parent
    If deferredOperation is a valid handle, it must have been created, allocated, or retrieved from device

  • VUID-vkCreateDataGraphPipelinesARM-pipelineCache-parent
    If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes
Success

  • VK_PIPELINE_COMPILE_REQUIRED_EXT

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

The VkDataGraphPipelineCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineCreateInfoARM {
    VkStructureType                              sType;
    const void*                                  pNext;
    VkPipelineCreateFlags2KHR                    flags;
    VkPipelineLayout                             layout;
    uint32_t                                     resourceInfoCount;
    const VkDataGraphPipelineResourceInfoARM*    pResourceInfos;
} VkDataGraphPipelineCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • flags is a bitmask of VkPipelineCreateFlagBits2KHR specifying how the pipeline will be generated.

  • layout is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

  • resourceInfoCount is the length of the pResourceInfos array.

  • pResourceInfos is a pointer to an array of VkDataGraphPipelineResourceInfoARM structures.

Applications can create a data graph pipeline entirely from data present in a pipeline cache. This is done by including a VkDataGraphPipelineIdentifierCreateInfoARM structure in the pNext chain. If the required data is not found in the pipeline cache, creating the data graph pipeline is not possible and the implementation must fail as specified by VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT.

When an identifier is used to create a data graph pipeline, implementations may fail pipeline creation with VK_PIPELINE_COMPILE_REQUIRED for any reason.

Valid Usage

  • VUID-VkDataGraphPipelineCreateInfoARM-pNext-09763
    One and only one of the following structures must be included in the pNext chain:

  • VUID-VkDataGraphPipelineCreateInfoARM-flags-09764
    flags may only contain VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT, VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT, VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT, VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR or VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR

  • VUID-VkDataGraphPipelineCreateInfoARM-layout-09767
    layout must have been created with pushConstantRangeCount equal to 0 and pPushConstantRanges equal to NULL

  • VUID-VkDataGraphPipelineCreateInfoARM-dataGraphUpdateAfterBind-09768
    If the dataGraphUpdateAfterBind feature is not enabled, layout must not use any VkDescriptorSetLayout object created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set

  • VUID-VkDataGraphPipelineCreateInfoARM-dataGraphDescriptorBuffer-09885
    If the dataGraphDescriptorBuffer feature is not enabled, flags must not contain VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT

  • VUID-VkDataGraphPipelineCreateInfoARM-module-09769
    If a resource variable is declared in VkDataGraphPipelineShaderModuleCreateInfoARM::module, a descriptor slot in layout must match the descriptor type

  • VUID-VkDataGraphPipelineCreateInfoARM-pNext-09875
    If a VkDataGraphPipelineIdentifierCreateInfoARM structure is included in the pNext chain, then flags must contain VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT

  • VUID-VkDataGraphPipelineCreateInfoARM-pNext-09876
    If a VkDataGraphPipelineIdentifierCreateInfoARM structure is included in the pNext chain, then a VkDataGraphPipelineShaderModuleCreateInfoARM structure must not be included in the pNext chain

  • VUID-VkDataGraphPipelineCreateInfoARM-pNext-09882
    If a VkDataGraphPipelineIdentifierCreateInfoARM structure is included in the pNext chain, then resourceInfoCount must be 0 and pResourceInfos must be NULL

  • VUID-VkDataGraphPipelineCreateInfoARM-dataGraphShaderModule-09886
    If the dataGraphShaderModule feature is not enabled, a VkDataGraphPipelineShaderModuleCreateInfoARM structure must not be included in the pNext chain

  • VUID-VkDataGraphPipelineCreateInfoARM-module-09934
    If a resource variable is declared in module as an array, a descriptor slot in layout must match the descriptor count

  • VUID-VkDataGraphPipelineCreateInfoARM-pipelineCreationCacheControl-09871
    If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR or VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR

  • VUID-VkDataGraphPipelineCreateInfoARM-pSetLayouts-09770
    The descriptor set layouts in VkPipelineLayoutCreateInfo::pSetLayouts used to create layout must not include any VkDescriptorSetLayoutBinding whose descriptor type is VK_DESCRIPTOR_TYPE_MUTABLE_EXT

  • VUID-VkDataGraphPipelineCreateInfoARM-pResourceInfos-09771
    For each of the structures in pResourceInfos, VkDataGraphPipelineResourceInfoARM::descriptorSet and VkDataGraphPipelineResourceInfoARM::binding must correspond to a resource variable declared in module

  • VUID-VkDataGraphPipelineCreateInfoARM-pipelineProtectedAccess-09772
    If the pipelineProtectedAccess feature is not enabled, flags must not include VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT or VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT

  • VUID-VkDataGraphPipelineCreateInfoARM-flags-09773
    flags must not include both VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT and VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT

  • VUID-VkDataGraphPipelineCreateInfoARM-pNext-09804
    If the pNext chain includes an VkPipelineCreationFeedbackCreateInfo structure, then its pipelineStageCreationFeedbackCount must be 0

Valid Usage (Implicit)

The VkDataGraphPipelineShaderModuleCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM {
    VkStructureType                          sType;
    const void*                              pNext;
    VkShaderModule                           module;
    const char*                              pName;
    const VkSpecializationInfo*              pSpecializationInfo;
    uint32_t                                 constantCount;
    const VkDataGraphPipelineConstantARM*    pConstants;
} VkDataGraphPipelineShaderModuleCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • module is optionally a VkShaderModule object containing the description of the graph.

  • pName is a pointer to a null-terminated UTF-8 string specifying the graph entry point name for this pipeline.

  • pSpecializationInfo is a pointer to a VkSpecializationInfo structure as described in Specialization Constants, or NULL.

  • constantCount is the length of the pConstants array.

  • pConstants is a pointer to an array of VkDataGraphPipelineConstantARM structures.

If module is not VK_NULL_HANDLE, the pipeline’s graph is defined by module. If module is VK_NULL_HANDLE, the pipeline’s graph is defined by the chained VkShaderModuleCreateInfo.

Valid Usage

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-id-09774
    The id member of all structures in pConstants must be a valid GraphConstantID used by a OpGraphConstantARM instruction in module

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-dataGraphSpecializationConstants-09849
    If the dataGraphSpecializationConstants feature is not enabled then pSpecializationInfo must be NULL and module must not contain any OpSpec* instructions

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pName-09872
    pName must be the name of an OpGraphEntryPointARM in module

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pNext-09873
    If the pNext chain includes a VkShaderModuleCreateInfo structure, then module must be VK_NULL_HANDLE

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pNext-09874
    If the pNext chain does not include a VkShaderModuleCreateInfo structure, then module must be a valid VkShaderModule

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-module-parameter
    If module is not VK_NULL_HANDLE, module must be a valid VkShaderModule handle

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pName-parameter
    pName must be a null-terminated UTF-8 string

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pSpecializationInfo-parameter
    If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure

  • VUID-VkDataGraphPipelineShaderModuleCreateInfoARM-pConstants-parameter
    If constantCount is not 0, and pConstants is not NULL, pConstants must be a valid pointer to an array of constantCount valid VkDataGraphPipelineConstantARM structures

The VkDataGraphPipelineIdentifierCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineIdentifierCreateInfoARM {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           identifierSize;
    const uint8_t*     pIdentifier;
} VkDataGraphPipelineIdentifierCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • identifierSize is the size in bytes of the identifier data accessible via pIdentifier.

  • pIdentifer is a pointer to identifierSize bytes of data that describe the pipeline being created.

Valid Usage

  • VUID-VkDataGraphPipelineIdentifierCreateInfoARM-pIdentifer-09877
    The data provided via pIdentifer must have been obtained by calling vkGetDataGraphPipelinePropertiesARM to query the value of the VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM property

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineIdentifierCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM

  • VUID-VkDataGraphPipelineIdentifierCreateInfoARM-pIdentifier-parameter
    pIdentifier must be a valid pointer to an array of identifierSize uint8_t values

  • VUID-VkDataGraphPipelineIdentifierCreateInfoARM-identifierSize-arraylength
    identifierSize must be greater than 0

The VkDataGraphPipelineCompilerControlCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM {
    VkStructureType    sType;
    const void*        pNext;
    const char*        pVendorOptions;
} VkDataGraphPipelineCompilerControlCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • pVendorOptions is a null-terminated UTF-8 string specifying implementation-specific options that affect the creation of a data graph pipeline.

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineCompilerControlCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM

  • VUID-VkDataGraphPipelineCompilerControlCreateInfoARM-pVendorOptions-parameter
    pVendorOptions must be a null-terminated UTF-8 string

The VkDataGraphPipelineConstantARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineConstantARM {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           id;
    const void*        pConstantData;
} VkDataGraphPipelineConstantARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is a pointer to a structure extending this structure.

  • id is the unique identifier of the graph constant this structure describes.

  • pConstantData is a pointer to the data for this graph constant.

The size and layout of the data pointed to by pConstantData is specified by a specific structure in the pNext chain for each type of graph constant.

For graph constants of tensor type, the layout of the data is specified by a VkTensorDescriptionARM structure. The data must be laid out according to the following members of this structure:

The presence of a VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM structure in the pNext chain has no impact on the expected layout of the data pointed to by pConstantData.

Valid Usage
Valid Usage (Implicit)

The VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM structure is defined as:

// Provided by VK_ARM_data_graph with VK_ARM_tensors
typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           dimension;
    uint32_t           zeroCount;
    uint32_t           groupSize;
} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • dimension is the dimension of the tensor along which its data is sparse.

  • zeroCount is the number of tensor elements that must be zero in every group of groupSize elements.

  • groupSize is the number of tensor elements in a group.

This extension does not provide applications with a way of knowing which combinations of dimension, zeroCount, and groupSize an implementation can take advantage of. Providing sparsity information for a graph constant is always valid and recommended, regardless of the specific combinations an implementation can take advantage of. When they can not take advantage of the sparsity information, implementations will ignore it and treat the data as dense.
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM

The VkDataGraphPipelineResourceInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineResourceInfoARM {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           descriptorSet;
    uint32_t           binding;
    uint32_t           arrayElement;
} VkDataGraphPipelineResourceInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • descriptorSet is the descriptor set number of the resource being described.

  • binding is the binding number of the resource being described.

  • arrayElement is the element in the resource array if descriptorSet and binding identifies an array of resources or 0 otherwise.

Valid Usage

  • VUID-VkDataGraphPipelineResourceInfoARM-arrayElement-09779
    arrayElement must be 0

  • VUID-VkDataGraphPipelineResourceInfoARM-descriptorSet-09851
    If descriptorSet and binding identify a tensor resource or an array of tensor resources, then a VkTensorDescriptionARM structure whose usage contains VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM must be included in the pNext chain

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineResourceInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM

  • VUID-VkDataGraphPipelineResourceInfoARM-pNext-pNext
    pNext must be NULL or a pointer to a valid instance of VkTensorDescriptionARM

  • VUID-VkDataGraphPipelineResourceInfoARM-sType-unique
    The sType value of each structure in the pNext chain must be unique

Sessions

Graph pipelines execute within data graph pipeline sessions that provide a context for their execution as well as binding points for the memory they need (e.g. transient storage).

Graph pipeline sessions are represented by VkDataGraphPipelineSessionARM handles:

// Provided by VK_ARM_data_graph
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM)

To create a data graph pipeline session, call

// Provided by VK_ARM_data_graph
VkResult vkCreateDataGraphPipelineSessionARM(
    VkDevice                                    device,
    const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDataGraphPipelineSessionARM*              pSession);
Valid Usage (Implicit)

  • VUID-vkCreateDataGraphPipelineSessionARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkCreateDataGraphPipelineSessionARM-pCreateInfo-parameter
    pCreateInfo must be a valid pointer to a valid VkDataGraphPipelineSessionCreateInfoARM structure

  • VUID-vkCreateDataGraphPipelineSessionARM-pAllocator-parameter
    If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

  • VUID-vkCreateDataGraphPipelineSessionARM-pSession-parameter
    pSession must be a valid pointer to a VkDataGraphPipelineSessionARM handle

  • VUID-vkCreateDataGraphPipelineSessionARM-device-queuecount
    The device must have been created with at least 1 queue

Return Codes
Success

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

The VkDataGraphPipelineSessionCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineSessionCreateInfoARM {
    VkStructureType                             sType;
    const void*                                 pNext;
    VkDataGraphPipelineSessionCreateFlagsARM    flags;
    VkPipeline                                  dataGraphPipeline;
} VkDataGraphPipelineSessionCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • flags is a bitmask of VkDataGraphPipelineSessionCreateFlagBitsARM describing additional parameters of the session.

  • dataGraphPipeline is the VkPipeline handle of the data graph pipeline for which a session is being created.

Valid Usage

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-dataGraphPipeline-09781
    dataGraphPipeline must have been obtained via a call to vkCreateDataGraphPipelinesARM

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-protectedMemory-09782
    If the protectedMemory feature is not enabled, flags must not contain VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-flags-parameter
    flags must be a valid combination of VkDataGraphPipelineSessionCreateFlagBitsARM values

  • VUID-VkDataGraphPipelineSessionCreateInfoARM-dataGraphPipeline-parameter
    dataGraphPipeline must be a valid VkPipeline handle

Bits which can be set in VkDataGraphPipelineSessionCreateInfoARM::flags, specifying additional parameters of a data graph pipeline session, are:

// Provided by VK_ARM_data_graph
// Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM
typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM;
static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL;

  • VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM specifies that the data graph pipeline session is backed by protected memory.

// Provided by VK_ARM_data_graph
typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM;

VkDataGraphPipelineSessionCreateFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphPipelineSessionCreateFlagBitsARM.

To determine the bind point requirements for a data graph pipeline session, call:

// Provided by VK_ARM_data_graph
VkResult vkGetDataGraphPipelineSessionBindPointRequirementsARM(
    VkDevice                                    device,
    const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo,
    uint32_t*                                   pBindPointRequirementCount,
    VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements);

If pBindPointRequirements is NULL, then the number of bind points associated with the data graph pipeline session is returned in pBindPointRequirementCount. Otherwise, pBindPointRequirementCount must point to a variable set by the user to the number of elements in the pBindPointRequirements array, and on return the variable is overwritten with the number of structures actually written to pBindPointRequirements. If pBindPointRequirementCount is less than the number of bind points associated with the data graph pipeline session, at most pBindPointRequirementCount structures will be written, and VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the required bind points were returned.

Valid Usage

  • VUID-vkGetDataGraphPipelineSessionBindPointRequirementsARM-session-09783
    The session member of pInfo must have been created with device

Valid Usage (Implicit)

  • VUID-vkGetDataGraphPipelineSessionBindPointRequirementsARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkGetDataGraphPipelineSessionBindPointRequirementsARM-pInfo-parameter
    pInfo must be a valid pointer to a valid VkDataGraphPipelineSessionBindPointRequirementsInfoARM structure

  • VUID-vkGetDataGraphPipelineSessionBindPointRequirementsARM-pBindPointRequirementCount-parameter
    pBindPointRequirementCount must be a valid pointer to a uint32_t value

  • VUID-vkGetDataGraphPipelineSessionBindPointRequirementsARM-pBindPointRequirements-parameter
    If the value referenced by pBindPointRequirementCount is not 0, and pBindPointRequirements is not NULL, pBindPointRequirements must be a valid pointer to an array of pBindPointRequirementCount VkDataGraphPipelineSessionBindPointRequirementARM structures

Return Codes
Success

  • VK_INCOMPLETE

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM {
    VkStructureType                  sType;
    const void*                      pNext;
    VkDataGraphPipelineSessionARM    session;
} VkDataGraphPipelineSessionBindPointRequirementsInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • session is a VkDataGraphPipelineSessionARM specifying the data graph pipeline session whose bind point requirements are being queried.

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineSessionBindPointRequirementsInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM

  • VUID-VkDataGraphPipelineSessionBindPointRequirementsInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineSessionBindPointRequirementsInfoARM-session-parameter
    session must be a valid VkDataGraphPipelineSessionARM handle

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineSessionBindPointRequirementARM {
    VkStructureType                               sType;
    const void*                                   pNext;
    VkDataGraphPipelineSessionBindPointARM        bindPoint;
    VkDataGraphPipelineSessionBindPointTypeARM    bindPointType;
    uint32_t                                      numObjects;
} VkDataGraphPipelineSessionBindPointRequirementARM;

Implementations must always return 1 for numObjects if bindPoint is one of the following bind points:

  • VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM

Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineSessionBindPointRequirementARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM

  • VUID-VkDataGraphPipelineSessionBindPointRequirementARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineSessionBindPointRequirementARM-bindPoint-parameter
    bindPoint must be a valid VkDataGraphPipelineSessionBindPointARM value

  • VUID-VkDataGraphPipelineSessionBindPointRequirementARM-bindPointType-parameter
    bindPointType must be a valid VkDataGraphPipelineSessionBindPointTypeARM value

Possible values of VkDataGraphPipelineSessionBindPointARM, specifying the bind point of a data graph pipeline session, are:

// Provided by VK_ARM_data_graph
typedef enum VkDataGraphPipelineSessionBindPointARM {
    VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0,
} VkDataGraphPipelineSessionBindPointARM;

  • VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM corresponds to the transient data produced and consumed during one dispatch of a data graph pipeline in a data graph pipeline session. This transient data is never reused by subsequent dispatches and can safely be clobbered once a vkCmdDispatchDataGraphARM command completes execution.

Possible values of VkDataGraphPipelineSessionBindPointTypeARM, specifying the type of a bind point of a data graph pipeline session, are:

// Provided by VK_ARM_data_graph
typedef enum VkDataGraphPipelineSessionBindPointTypeARM {
    VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0,
} VkDataGraphPipelineSessionBindPointTypeARM;

  • VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM corresponds to a memory allocation.

To determine the memory requirements for a data graph pipeline session, call:

// Provided by VK_ARM_data_graph
void vkGetDataGraphPipelineSessionMemoryRequirementsARM(
    VkDevice                                    device,
    const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

  • device is the logical device that owns the data graph pipeline session.

  • pInfo is a pointer to a VkDataGraphPipelineSessionMemoryRequirementsInfoARM structure containing parameters for the memory requirements query.

  • pMemoryRequirements is a pointer to a VkMemoryRequirements2 structure in which the memory requirements of the data graph pipeline session object are returned.

Valid Usage
Valid Usage (Implicit)

  • VUID-vkGetDataGraphPipelineSessionMemoryRequirementsARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkGetDataGraphPipelineSessionMemoryRequirementsARM-pInfo-parameter
    pInfo must be a valid pointer to a valid VkDataGraphPipelineSessionMemoryRequirementsInfoARM structure

  • VUID-vkGetDataGraphPipelineSessionMemoryRequirementsARM-pMemoryRequirements-parameter
    pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure

The VkDataGraphPipelineSessionMemoryRequirementsInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM {
    VkStructureType                           sType;
    const void*                               pNext;
    VkDataGraphPipelineSessionARM             session;
    VkDataGraphPipelineSessionBindPointARM    bindPoint;
    uint32_t                                  objectIndex;
} VkDataGraphPipelineSessionMemoryRequirementsInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • session is the data graph pipeline session to query.

  • bindPoint is the bind point of a data graph pipeline session for which memory requirements are being queried.

  • objectIndex is the index of the object whose memory requirements are being queried.

Valid Usage
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineSessionMemoryRequirementsInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM

  • VUID-VkDataGraphPipelineSessionMemoryRequirementsInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineSessionMemoryRequirementsInfoARM-session-parameter
    session must be a valid VkDataGraphPipelineSessionARM handle

  • VUID-VkDataGraphPipelineSessionMemoryRequirementsInfoARM-bindPoint-parameter
    bindPoint must be a valid VkDataGraphPipelineSessionBindPointARM value

To attach memory to a data graph pipeline session object, call:

// Provided by VK_ARM_data_graph
VkResult vkBindDataGraphPipelineSessionMemoryARM(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos);

  • device is the logical device that owns the data graph pipeline session and memory.

  • bindInfoCount is the length of the pBindInfos array.

  • pBindInfos is a pointer to an array of VkBindDataGraphPipelineSessionMemoryInfoARM structures describing graph pipeline sessions and memory to bind.

Valid Usage (Implicit)

  • VUID-vkBindDataGraphPipelineSessionMemoryARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkBindDataGraphPipelineSessionMemoryARM-pBindInfos-parameter
    pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindDataGraphPipelineSessionMemoryInfoARM structures

  • VUID-vkBindDataGraphPipelineSessionMemoryARM-bindInfoCount-arraylength
    bindInfoCount must be greater than 0

Return Codes
Success

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

The VkBindDataGraphPipelineSessionMemoryInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM {
    VkStructureType                           sType;
    const void*                               pNext;
    VkDataGraphPipelineSessionARM             session;
    VkDataGraphPipelineSessionBindPointARM    bindPoint;
    uint32_t                                  objectIndex;
    VkDeviceMemory                            memory;
    VkDeviceSize                              memoryOffset;
} VkBindDataGraphPipelineSessionMemoryInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • session is the data graph pipeline session to be attached to memory.

  • bindPoint is the data graph pipeline session bind point to which memory is to be attached.

  • objectIndex is the index of the object for bindPoint at which memory is to be attached.

  • memory is a VkDeviceMemory object describing the device memory to attach.

  • memoryOffset is the start offset of the resion of memory which is to be bound to the data graph pipeline session.

Valid Usage

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-session-09785
    session must not have been bound to a memory object for bindPoint

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-bindPoint-09786
    bindPoint must have been returned as part of a VkDataGraphPipelineSessionBindPointRequirementARM whose bindPointType member is VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM by a prior call to vkGetDataGraphPipelineSessionMemoryRequirementsARM for session

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-memoryOffset-09787
    memoryOffset must be less than the size of memory

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-memory-09788
    memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetDataGraphPipelineSessionMemoryRequirementsARM with session

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-memoryOffset-09789
    memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetDataGraphPipelineSessionMemoryRequirementsARM with session

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-size-09790
    The size member of the VkMemoryRequirements structure returned from a call to vkGetDataGraphPipelineSessionMemoryRequirementsARM with session must be less than or equal to the size of memory minus memoryOffset

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-session-09791
    If session was created with the VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM bit set, the session must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-session-09792
    If session was created with the VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM bit not set, the session must not be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-objectIndex-09805
    objectIndex must be less than the value of numObjects returned by vkGetDataGraphPipelineSessionBindPointRequirementsARM for bindPoint

Valid Usage (Implicit)

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-session-parameter
    session must be a valid VkDataGraphPipelineSessionARM handle

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-bindPoint-parameter
    bindPoint must be a valid VkDataGraphPipelineSessionBindPointARM value

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-memory-parameter
    memory must be a valid VkDeviceMemory handle

  • VUID-VkBindDataGraphPipelineSessionMemoryInfoARM-commonparent
    Both of memory, and session must have been created, allocated, or retrieved from the same VkDevice

To destroy a data graph pipeline session, call:

// Provided by VK_ARM_data_graph
void vkDestroyDataGraphPipelineSessionARM(
    VkDevice                                    device,
    VkDataGraphPipelineSessionARM               session,
    const VkAllocationCallbacks*                pAllocator);

  • device is the logical device that destroys the data graph pipeline session.

  • session is the handle of the data graph pipeline session to destroy.

  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

  • VUID-vkDestroyDataGraphPipelineSessionARM-session-09793
    All submitted commands that refer to session must have completed execution

  • VUID-vkDestroyDataGraphPipelineSessionARM-session-09794
    If VkAllocationCallbacks were provided when session was created, a compatible set of callbacks must be provided here

  • VUID-vkDestroyDataGraphPipelineSessionARM-session-09795
    If no VkAllocationCallbacks were provided when session was created, pAllocator must be NULL

Valid Usage (Implicit)

  • VUID-vkDestroyDataGraphPipelineSessionARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkDestroyDataGraphPipelineSessionARM-session-parameter
    session must be a valid VkDataGraphPipelineSessionARM handle

  • VUID-vkDestroyDataGraphPipelineSessionARM-pAllocator-parameter
    If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

  • VUID-vkDestroyDataGraphPipelineSessionARM-session-parent
    session must have been created, allocated, or retrieved from device

Host Synchronization

  • Host access to session must be externally synchronized

Dispatch

To record a data graph pipeline dispatch, call:

// Provided by VK_ARM_data_graph
void vkCmdDispatchDataGraphARM(
    VkCommandBuffer                             commandBuffer,
    VkDataGraphPipelineSessionARM               session,
    const VkDataGraphPipelineDispatchInfoARM*   pInfo);
Valid Usage

  • VUID-vkCmdDispatchDataGraphARM-session-09796
    For each of the session bind point requirements returned by vkGetDataGraphPipelineSessionBindPointRequirementsARM for session, VkDataGraphPipelineSessionBindPointRequirementARM::numObjects objects must have been bound to session

  • VUID-vkCmdDispatchDataGraphARM-None-09797
    For each set n that is statically used by a bound data graph pipeline, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility

  • VUID-vkCmdDispatchDataGraphARM-None-09935
    Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT

  • VUID-vkCmdDispatchDataGraphARM-None-09936
    If the descriptors used by the VkPipeline bound to the pipeline bind point were specified via vkCmdBindDescriptorSets, the bound VkPipeline must have been created without VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT

  • VUID-vkCmdDispatchDataGraphARM-None-09937
    Descriptors in bound descriptor buffers, specified via vkCmdSetDescriptorBufferOffsetsEXT, must be valid if they are dynamically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT

  • VUID-vkCmdDispatchDataGraphARM-None-09938
    If the descriptors used by the VkPipeline bound to the pipeline bind point were specified via vkCmdSetDescriptorBufferOffsetsEXT, the bound VkPipeline must have been created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT

  • VUID-vkCmdDispatchDataGraphARM-None-09939
    If a descriptor is dynamically used with a VkPipeline created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, the descriptor memory must be resident

  • VUID-vkCmdDispatchDataGraphARM-None-09799
    A valid data graph pipeline must be bound to the VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM pipeline bind point used by this command

  • VUID-vkCmdDispatchDataGraphARM-pDescription-09930
    If a VK_DESCRIPTOR_TYPE_TENSOR_ARM descriptor is accessed as a result of this command, then the underlying VkTensorARM object must have been created with a VkTensorCreateInfoARM::pDescription whose usage member contained VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-09940
    If commandBuffer was allocated from a pool that was created with a VkDataGraphProcessingEngineCreateInfoARM structure in the pNext chain of VkCommandPoolCreateInfo that included a foreign data graph processing engine in its pProcessingEngines member, then all VK_DESCRIPTOR_TYPE_TENSOR_ARM descriptors accessed as a result of this command must be tied to VkTensorARM objects that have been bound to memory created from external handle types reported as supported in a VkQueueFamilyDataGraphProcessingEnginePropertiesARM::foreignMemoryHandleTypes structure via vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM with a queueFamilyIndex matching the one the command pool was created for, for all the foreign data graph processing engines that were part of the VkDataGraphProcessingEngineCreateInfoARM used to create the command pool

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-09800
    If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound data graph pipelines must not be a protected resource

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-09801
    If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the bind point used by this command must not be an unprotected resource

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-09941
    All the operations used by the bound data graph pipeline must be supported on the queue family for which the command pool out of which commandBuffer was allocated, as reported by vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM

Valid Usage (Implicit)

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-parameter
    commandBuffer must be a valid VkCommandBuffer handle

  • VUID-vkCmdDispatchDataGraphARM-session-parameter
    session must be a valid VkDataGraphPipelineSessionARM handle

  • VUID-vkCmdDispatchDataGraphARM-pInfo-parameter
    If pInfo is not NULL, pInfo must be a valid pointer to a valid VkDataGraphPipelineDispatchInfoARM structure

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-recording
    commandBuffer must be in the recording state

  • VUID-vkCmdDispatchDataGraphARM-commandBuffer-cmdpool
    The VkCommandPool that commandBuffer was allocated from must support data_graph operations

  • VUID-vkCmdDispatchDataGraphARM-renderpass
    This command must only be called outside of a render pass instance

  • VUID-vkCmdDispatchDataGraphARM-videocoding
    This command must only be called outside of a video coding scope

  • VUID-vkCmdDispatchDataGraphARM-commonparent
    Both of commandBuffer, and session must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

  • Host access to commandBuffer must be externally synchronized

  • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Video Coding Scope Supported Queue Types Command Type

Primary
Secondary

Outside

Outside

Data_Graph

Action
Conditional Rendering

vkCmdDispatchDataGraphARM is affected by conditional rendering

The VkDataGraphPipelineDispatchInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineDispatchInfoARM {
    VkStructureType                        sType;
    void*                                  pNext;
    VkDataGraphPipelineDispatchFlagsARM    flags;
} VkDataGraphPipelineDispatchInfoARM;
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineDispatchInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM

  • VUID-VkDataGraphPipelineDispatchInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineDispatchInfoARM-flags-zerobitmask
    flags must be 0

Bits which can be set in VkDataGraphPipelineDispatchInfoARM::flags, specifying additional parameters of a data graph pipeline dispatch, are:

// Provided by VK_ARM_data_graph
// Flag bits for VkDataGraphPipelineDispatchFlagBitsARM
typedef VkFlags64 VkDataGraphPipelineDispatchFlagBitsARM;
// Provided by VK_ARM_data_graph
typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM;

VkDataGraphPipelineDispatchFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphPipelineDispatchFlagBitsARM.

Properties

To query the properties of a data graph pipeline that can be obtained, call:

// Provided by VK_ARM_data_graph
VkResult vkGetDataGraphPipelineAvailablePropertiesARM(
    VkDevice                                    device,
    const VkDataGraphPipelineInfoARM*           pPipelineInfo,
    uint32_t*                                   pPropertiesCount,
    VkDataGraphPipelinePropertyARM*             pProperties);

  • device is the logical device that created the data graph pipeline.

  • pPipelineInfo is a VkDataGraphPipelineInfoARM that describes the VkPipeline being queried.

  • pPropertiesCount is a pointer to an integer related to the number of properties available or queried, as described below.

  • pProperties is either NULL or a pointer to an array of VkDataGraphPipelinePropertyARM enums.

If pProperties is NULL, then the number of properties associated with the data graph pipeline is returned in pPropertiesCount. Otherwise, pPropertiesCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of enums actually written to pProperties. If pPropertiesCount is less than the number of properties associated with the data graph pipeline, at most pPropertiesCount structures will be written, and VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available properties were returned.

Valid Usage

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-dataGraphPipeline-09887
    The dataGraphPipeline member of pPipelineInfo must have been returned by a call to vkCreateDataGraphPipelinesARM

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-dataGraphPipeline-09888
    The dataGraphPipeline member of pPipelineInfo must have been created with device

Valid Usage (Implicit)

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-pPipelineInfo-parameter
    pPipelineInfo must be a valid pointer to a valid VkDataGraphPipelineInfoARM structure

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-pPropertiesCount-parameter
    pPropertiesCount must be a valid pointer to a uint32_t value

  • VUID-vkGetDataGraphPipelineAvailablePropertiesARM-pProperties-parameter
    If the value referenced by pPropertiesCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertiesCount VkDataGraphPipelinePropertyARM values

Return Codes
Success

  • VK_INCOMPLETE

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

To query properties of a data graph pipeline, call:

// Provided by VK_ARM_data_graph
VkResult vkGetDataGraphPipelinePropertiesARM(
    VkDevice                                    device,
    const VkDataGraphPipelineInfoARM*           pPipelineInfo,
    uint32_t                                    propertiesCount,
    VkDataGraphPipelinePropertyQueryResultARM*  pProperties);
Valid Usage

  • VUID-vkGetDataGraphPipelinePropertiesARM-dataGraphPipeline-09869
    The dataGraphPipeline member of pPipelineInfo must have been returned by a call to vkCreateDataGraphPipelinesARM

  • VUID-vkGetDataGraphPipelinePropertiesARM-dataGraphPipeline-09802
    The dataGraphPipeline member of pPipelineInfo must have been created with device

  • VUID-vkGetDataGraphPipelinePropertiesARM-pProperties-09889
    There must not be two or more structures in the pProperties array with the same VkDataGraphPipelinePropertyQueryResultARM::property

Valid Usage (Implicit)

  • VUID-vkGetDataGraphPipelinePropertiesARM-device-parameter
    device must be a valid VkDevice handle

  • VUID-vkGetDataGraphPipelinePropertiesARM-pPipelineInfo-parameter
    pPipelineInfo must be a valid pointer to a valid VkDataGraphPipelineInfoARM structure

  • VUID-vkGetDataGraphPipelinePropertiesARM-pProperties-parameter
    pProperties must be a valid pointer to an array of propertiesCount VkDataGraphPipelinePropertyQueryResultARM structures

  • VUID-vkGetDataGraphPipelinePropertiesARM-propertiesCount-arraylength
    propertiesCount must be greater than 0

Return Codes
Success

  • VK_INCOMPLETE

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

The VkDataGraphPipelineInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineInfoARM {
    VkStructureType    sType;
    const void*        pNext;
    VkPipeline         dataGraphPipeline;
} VkDataGraphPipelineInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • dataGraphPipeline is a VkPipeline handle.

Valid Usage
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM

  • VUID-VkDataGraphPipelineInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelineInfoARM-dataGraphPipeline-parameter
    dataGraphPipeline must be a valid VkPipeline handle

The VkDataGraphPipelinePropertyQueryResultARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelinePropertyQueryResultARM {
    VkStructureType                   sType;
    const void*                       pNext;
    VkDataGraphPipelinePropertyARM    property;
    VkBool32                          isText;
    size_t                            dataSize;
    void*                             pData;
} VkDataGraphPipelinePropertyQueryResultARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • property is a VkDataGraphPipelinePropertyARM specifying the property of the data graph pipeline being queried.

  • isText specifies whether the returned data is text or opaque data. If isText is VK_TRUE then the data returned in pData is text and guaranteed to be a null-terminated UTF-8 string.

  • dataSize is an integer related to the size, in bytes, of the data, as described below.

  • pData is either NULL or a pointer to a block of memory into which the implementation will return the property data.

If pData is NULL, then the size, in bytes, of the property data is returned in dataSize. Otherwise, dataSize must be the size of the buffer, in bytes, pointed to by pData and on return dataSize is overwritten with the number of bytes of data actually written to pData including any trailing NUL character. If dataSize is less than the size, in bytes, of the property data, at most dataSize bytes of data will be written to pData, and VK_INCOMPLETE will be returned by vkGetDataGraphPipelinePropertiesARM instead of VK_SUCCESS, to indicate that not all the available property data was returned. If isText is VK_TRUE and pData is not NULL and dataSize is not zero, the last byte written to pData will be a NUL character.

Valid Usage
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelinePropertyQueryResultARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM

  • VUID-VkDataGraphPipelinePropertyQueryResultARM-pNext-pNext
    pNext must be NULL

  • VUID-VkDataGraphPipelinePropertyQueryResultARM-property-parameter
    property must be a valid VkDataGraphPipelinePropertyARM value

  • VUID-VkDataGraphPipelinePropertyQueryResultARM-pData-parameter
    If dataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of dataSize bytes

Possible values of VkDataGraphPipelinePropertyQueryResultARM::property, specifying the property of the data graph pipeline being queried, are:

// Provided by VK_ARM_data_graph
typedef enum VkDataGraphPipelinePropertyARM {
    VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0,
    VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1,
} VkDataGraphPipelinePropertyARM;

  • VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM corresponds to a human-readable log produced during the creation of a data graph pipeline. It may contain information about errors encountered during the creation or other information generally useful for debugging. This property can be queried for any data graph pipeline.

  • VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM corresponds to an opaque identifier for the data graph pipeline. It can be used to create a graph pipeline from a pipeline cache without the need to provide any creation data beyond the identifier, using a VkDataGraphPipelineIdentifierCreateInfoARM structure.

Processing Engines

Data graph pipelines execute on one or more data graph processing engines. Each queue family of a VkPhysicalDevice that supports VK_QUEUE_DATA_GRAPH_BIT_ARM may provide access to processing engines. Processing engines may be foreign. Foreign processing engines require the use of external memory and semaphores to exchange data and synchronize with data graph pipelines that target them. Each processing engine may support a selection of graph operations. There exists a default processing engine that enables implementations to support some operations without tying support to specific processing engines. This allows implementations to avoid being specific about the processing engines that they use internally or to remove the necessity for applications to choose the specific processing engine used to execute a given set of operations.

To query the properties of a data graph processing engine for a specific queue family of a physical device, call:

// Provided by VK_ARM_data_graph
void vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo,
    VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties);
Valid Usage (Implicit)

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM-physicalDevice-parameter
    physicalDevice must be a valid VkPhysicalDevice handle

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM-pQueueFamilyDataGraphProcessingEngineInfo-parameter
    pQueueFamilyDataGraphProcessingEngineInfo must be a valid pointer to a valid VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM structure

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM-pQueueFamilyDataGraphProcessingEngineProperties-parameter
    pQueueFamilyDataGraphProcessingEngineProperties must be a valid pointer to a VkQueueFamilyDataGraphProcessingEnginePropertiesARM structure

The VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
    VkStructureType                                     sType;
    const void*                                         pNext;
    uint32_t                                            queueFamilyIndex;
    VkPhysicalDeviceDataGraphProcessingEngineTypeARM    engineType;
} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • queueFamilyIndex specifies the queue family being queried.

  • engineType is a VkPhysicalDeviceDataGraphProcessingEngineTypeARM specifying the engine type whose properties are being queried.

Valid Usage (Implicit)

  • VUID-VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM

  • VUID-VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM-pNext-pNext
    pNext must be NULL

  • VUID-VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM-engineType-parameter
    engineType must be a valid VkPhysicalDeviceDataGraphProcessingEngineTypeARM value

The VkQueueFamilyDataGraphProcessingEnginePropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalSemaphoreHandleTypeFlags    foreignSemaphoreHandleTypes;
    VkExternalMemoryHandleTypeFlags       foreignMemoryHandleTypes;
} VkQueueFamilyDataGraphProcessingEnginePropertiesARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • foreignSemaphoreHandleTypes is a VkExternalSemaphoreHandleTypeFlags that describes the external semaphore handle types supported by a foreign data graph processing engine.

  • foreignMemoryHandleTypes is a VkExternalMemoryHandleTypeFlags that describes the external memory handle types supported by a foreign data graph processing engine.

Valid Usage (Implicit)

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-pNext-pNext
    pNext must be NULL

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-foreignSemaphoreHandleTypes-parameter
    foreignSemaphoreHandleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-foreignSemaphoreHandleTypes-requiredbitmask
    foreignSemaphoreHandleTypes must not be 0

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-foreignMemoryHandleTypes-parameter
    foreignMemoryHandleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values

  • VUID-VkQueueFamilyDataGraphProcessingEnginePropertiesARM-foreignMemoryHandleTypes-requiredbitmask
    foreignMemoryHandleTypes must not be 0

The VkPhysicalDeviceDataGraphProcessingEngineARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM {
    VkPhysicalDeviceDataGraphProcessingEngineTypeARM    type;
    VkBool32                                            isForeign;
} VkPhysicalDeviceDataGraphProcessingEngineARM;
Valid Usage (Implicit)

The defined data graph processing engines are:

// Provided by VK_ARM_data_graph
typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM {
    VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0,
} VkPhysicalDeviceDataGraphProcessingEngineTypeARM;

  • VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM corresponds to the default data graph processing engine.

The VkDataGraphProcessingEngineCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphProcessingEngineCreateInfoARM {
    VkStructureType                                  sType;
    const void*                                      pNext;
    uint32_t                                         processingEngineCount;
    VkPhysicalDeviceDataGraphProcessingEngineARM*    pProcessingEngines;
} VkDataGraphProcessingEngineCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • processingEngineCount is the number of elements in pProcessingEngines.

  • pProcessingEngines is a pointer to an array of processingEngineCount VkPhysicalDeviceDataGraphProcessingEngineARM structures.

Valid Usage
Valid Usage (Implicit)

  • VUID-VkDataGraphProcessingEngineCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM

  • VUID-VkDataGraphProcessingEngineCreateInfoARM-pProcessingEngines-parameter
    pProcessingEngines must be a valid pointer to an array of processingEngineCount VkPhysicalDeviceDataGraphProcessingEngineARM structures

  • VUID-VkDataGraphProcessingEngineCreateInfoARM-processingEngineCount-arraylength
    processingEngineCount must be greater than 0

Operations

Data graph processing engines execute data graph operations. Operations may be of a fixed-function nature, configurable or not, or may , for example, be provided as part of a SPIR-V extended instruction set.

To query the data graph processing engines and operations they support for a specific queue family of a physical device, call:

// Provided by VK_ARM_data_graph
VkResult vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    uint32_t*                                   pQueueFamilyDataGraphPropertyCount,
    VkQueueFamilyDataGraphPropertiesARM*        pQueueFamilyDataGraphProperties);

  • physicalDevice is the physical device to query.

  • queueFamilyIndex is the index of the queue family being queried.

  • pQueueFamilyDataGraphPropertyCount is a pointer to an integer related to the number of properties available or queried.

  • pQueueFamilyDataGraphProperties is either NULL or a pointer to an array of VkQueueFamilyDataGraphPropertiesARM structures.

If pQueueFamilyDataGraphProperties is NULL, then the number of properties available is returned in pQueueFamilyDataGraphPropertyCount. Otherwise, pQueueFamilyDataGraphPropertyCount must point to a variable set by the application to the number of elements in the pQueueFamilyDataGraphProperties array, and on return the variable is overwritten with the number of structures actually written to pQueueFamilyDataGraphProperties. If pQueueFamilyDataGraphPropertyCount is less than the number of properties available, at most pQueueFamilyDataGraphPropertyCount structures will be written, and VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available properties were returned.

Valid Usage (Implicit)

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM-physicalDevice-parameter
    physicalDevice must be a valid VkPhysicalDevice handle

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM-pQueueFamilyDataGraphPropertyCount-parameter
    pQueueFamilyDataGraphPropertyCount must be a valid pointer to a uint32_t value

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM-pQueueFamilyDataGraphProperties-parameter
    If the value referenced by pQueueFamilyDataGraphPropertyCount is not 0, and pQueueFamilyDataGraphProperties is not NULL, pQueueFamilyDataGraphProperties must be a valid pointer to an array of pQueueFamilyDataGraphPropertyCount VkQueueFamilyDataGraphPropertiesARM structures

Return Codes
Success

  • VK_INCOMPLETE

  • VK_SUCCESS

Failure

  • VK_ERROR_OUT_OF_DEVICE_MEMORY

  • VK_ERROR_OUT_OF_HOST_MEMORY

  • VK_ERROR_UNKNOWN

  • VK_ERROR_VALIDATION_FAILED

The VkQueueFamilyDataGraphPropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkQueueFamilyDataGraphPropertiesARM {
    VkStructureType                                 sType;
    const void*                                     pNext;
    VkPhysicalDeviceDataGraphProcessingEngineARM    engine;
    VkPhysicalDeviceDataGraphOperationSupportARM    operation;
} VkQueueFamilyDataGraphPropertiesARM;
Valid Usage (Implicit)

  • VUID-VkQueueFamilyDataGraphPropertiesARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM

  • VUID-VkQueueFamilyDataGraphPropertiesARM-pNext-pNext
    pNext must be NULL

  • VUID-VkQueueFamilyDataGraphPropertiesARM-engine-parameter
    engine must be a valid VkPhysicalDeviceDataGraphProcessingEngineARM structure

  • VUID-VkQueueFamilyDataGraphPropertiesARM-operation-parameter
    operation must be a valid VkPhysicalDeviceDataGraphOperationSupportARM structure

The VkPhysicalDeviceDataGraphOperationSupportARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkPhysicalDeviceDataGraphOperationSupportARM {
    VkPhysicalDeviceDataGraphOperationTypeARM    operationType;
    char                                         name[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM];
    uint32_t                                     version;
} VkPhysicalDeviceDataGraphOperationSupportARM;

  • sType is a VkStructureType value identifying this structure.

  • pNext is NULL or a pointer to a structure extending this structure.

  • operationType is a VkPhysicalDeviceDataGraphOperationTypeARM enum specifying the type of the operation whose support is being described.

  • name is a pointer to a null-terminated UTF-8 string specifying the name of the operation whose support is being described.

  • version is an integer specifying the version of the operation whose support is being described.

Valid Usage (Implicit)

  • VUID-VkPhysicalDeviceDataGraphOperationSupportARM-operationType-parameter
    operationType must be a valid VkPhysicalDeviceDataGraphOperationTypeARM value

  • VUID-VkPhysicalDeviceDataGraphOperationSupportARM-name-parameter
    name must be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM

The defined data graph operations are:

// Provided by VK_ARM_data_graph
typedef enum VkPhysicalDeviceDataGraphOperationTypeARM {
    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0,
} VkPhysicalDeviceDataGraphOperationTypeARM;

  • VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM corresponds to operations provided by a SPIR-V extended instruction set.