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
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
Failure

The VkDataGraphPipelineCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineCreateInfoARM {
    VkStructureType                              sType;
    const void*                                  pNext;
    VkPipelineCreateFlags2                       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.

Applications can create a data graph pipeline without providing a pipeline cache or shader module by invoking one of the models provided by the implementation. This is done by including VkDataGraphPipelineBuiltinModelCreateInfoQCOM in the pNext chain.

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

The data graph engines for this pipeline can be selected by including a VkDataGraphProcessingEngineCreateInfoARM to the pNext chain of this structure. Otherwise, VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM will be used as the sole data graph engine.

The data graph operations that this pipeline uses must be supported for the data graph engines selected for this pipeline as retrieved by vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.

Valid Usage
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-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

Structure Chaining
Extends the structure

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.

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

The pIdentifier can be retrieved from the device by calling vkGetDataGraphPipelinePropertiesARM and searching the results for a VkDataGraphPipelinePropertyQueryResultARM structure with property set to VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM.

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

Structure Chaining
Extends the structure

The VkDataGraphPipelineBuiltinModelCreateInfoQCOM structure is defined as:

// Provided by VK_QCOM_data_graph_model
typedef struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
    VkStructureType                                        sType;
    const void*                                            pNext;
    const VkPhysicalDeviceDataGraphOperationSupportARM*    pOperation;
} VkDataGraphPipelineBuiltinModelCreateInfoQCOM;

The pipelineCache is ignored for the creation of this pipeline.

Applications can specify arguments to the built-in operation named in pOperation with VkDataGraphPipelineCompilerControlCreateInfoARM.

Applications should verify that the pVendorOptions, layout, and other state included with this pipeline creation are compatible with the pOperation. Implementations may fail if any state is not compatible and return VK_PIPELINE_COMPILE_REQUIRED.

Built-in models are defined by the provider of the model, therefore Vulkan does not define model compatibility. The application should refer to the provider of the built-in model for guidance on compatibility.
Valid Usage
Valid Usage (Implicit)
Structure Chaining
Extends the structure

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)
Structure Chaining
Extends the structure

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)
Structure Chaining
Extends the structure

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
Valid Usage (Implicit)

The VkDataGraphPipelineResourceInfoImageLayoutARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphPipelineResourceInfoImageLayoutARM {
    VkStructureType    sType;
    const void*        pNext;
    VkImageLayout      layout;
} VkDataGraphPipelineResourceInfoImageLayoutARM;

  • sType is a VkStructureType value identifying this structure.

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

  • layout specifies the layout that the image subresource accessible from the view provided as a graph pipeline resource must be in at the time where the graph pipeline being created is dispatched.

Valid Usage (Implicit)
Structure Chaining
Extends the structure

The VkDataGraphPipelineSingleNodeCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphPipelineSingleNodeCreateInfoARM {
    VkStructureType                                      sType;
    void*                                                pNext;
    VkDataGraphPipelineNodeTypeARM                       nodeType;
    uint32_t                                             connectionCount;
    const VkDataGraphPipelineSingleNodeConnectionARM*    pConnections;
} VkDataGraphPipelineSingleNodeCreateInfoARM;
Valid Usage
Valid Usage (Implicit)
Structure Chaining
Extends the structure

Possible values of VkDataGraphPipelineNodeTypeARM, specifying the type of a data graph pipeline node, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphPipelineNodeTypeARM {
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM = 1000631000,
} VkDataGraphPipelineNodeTypeARM;

The VkDataGraphPipelineSingleNodeConnectionARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphPipelineSingleNodeConnectionARM {
    VkStructureType                             sType;
    void*                                       pNext;
    uint32_t                                    set;
    uint32_t                                    binding;
    VkDataGraphPipelineNodeConnectionTypeARM    connection;
} VkDataGraphPipelineSingleNodeConnectionARM;

  • sType is a VkStructureType value identifying this structure.

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

  • set is the descriptor set number of the graph pipeline layout resource to be connected to this connection point.

  • binding is the binding number of the graph pipeline layout resource to be connected to this connection point.

  • connection is a VkDataGraphPipelineNodeConnectionTypeARM specifying the connection point to link to a graph pipeline layout resource.

Valid Usage (Implicit)

Possible values of VkDataGraphPipelineNodeConnectionTypeARM, specifying the connection points of a data graph pipeline node, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphPipelineNodeConnectionTypeARM {
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM = 1000631000,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM = 1000631001,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM = 1000631002,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM = 1000631003,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM = 1000631004,
} VkDataGraphPipelineNodeConnectionTypeARM;

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
Failure

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
Valid Usage (Implicit)

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;
// Provided by VK_ARM_data_graph_optical_flow
static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM = 0x00000002ULL;
// 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
Failure
// 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)
// Provided by VK_ARM_data_graph
typedef struct VkDataGraphPipelineSessionBindPointRequirementARM {
    VkStructureType                               sType;
    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:

Valid Usage (Implicit)

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,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM = 1000631001,
} VkDataGraphPipelineSessionBindPointARM;

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;

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)

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
Failure

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
Valid Usage (Implicit)

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
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 VK_QUEUE_DATA_GRAPH_BIT_ARM operations

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

  • VUID-vkCmdDispatchDataGraphARM-suspended
    This command must not be called between suspended render pass instances

  • 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

VK_QUEUE_DATA_GRAPH_BIT_ARM

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)

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-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
Failure

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-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
Failure

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;
    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 (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;

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)

The VkQueueFamilyDataGraphProcessingEnginePropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
    VkStructureType                       sType;
    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)

The VkPhysicalDeviceDataGraphProcessingEngineARM structure is defined as:

// Provided by VK_ARM_data_graph
typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM {
    VkPhysicalDeviceDataGraphProcessingEngineTypeARM    type;
    VkBool32                                            isForeign;
} VkPhysicalDeviceDataGraphProcessingEngineARM;

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,
  // Provided by VK_QCOM_data_graph_model
    VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000,
  // Provided by VK_QCOM_data_graph_model
    VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001,
} VkPhysicalDeviceDataGraphProcessingEngineTypeARM;

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)
Structure Chaining
Extends the structures

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.

If the dataGraphModel feature is supported, the implementation must return at least one property with engine type VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM or VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM.

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
Failure

The VkQueueFamilyDataGraphPropertiesARM structure is defined as:

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

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.

VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM is the length in char values of an array containing the name of a data graph operation, as returned in VkPhysicalDeviceDataGraphOperationSupportARM::name.

#define VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM 128U

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,
  // Provided by VK_QCOM_data_graph_model
    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000,
  // Provided by VK_QCOM_data_graph_model
    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001,
  // Provided by VK_ARM_data_graph_optical_flow
    VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM = 1000631000,
} VkPhysicalDeviceDataGraphOperationTypeARM;

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

// Provided by VK_ARM_data_graph_instruction_set_tosa, VK_ARM_data_graph_optical_flow
VkResult vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    const VkQueueFamilyDataGraphPropertiesARM*  pQueueFamilyDataGraphProperties,
    VkBaseOutStructure*                         pProperties);

  • physicalDevice is the physical device to query.

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

  • pQueueFamilyDataGraphProperties is a pointer to a VkQueueFamilyDataGraphPropertiesARM structure that selects the processing engine and operation set for which the properties are queried.

  • pProperties is a pointer to a structure in which the properties are returned.

Valid property queries for specific engines and operations
Engine Operation Type Operation Name Operation Version Property structure

Any

Any

TOSA.XXXXXX.X where X is a digit between 0 and 9

Any

VkQueueFamilyDataGraphTOSAPropertiesARM

Any

Any

OpticalFlow

Any

VkQueueFamilyDataGraphOpticalFlowPropertiesARM
Valid Usage
Valid Usage (Implicit)

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

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM-pQueueFamilyDataGraphProperties-parameter
    pQueueFamilyDataGraphProperties must be a valid pointer to a valid VkQueueFamilyDataGraphPropertiesARM structure

Return Codes
Success
Failure

Data Graph Operations Requirements

Physical devices that support the dataGraphShaderModule feature must support an operation whose VkPhysicalDeviceDataGraphOperationSupportARM::operationType is VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM and name and version are as described in the following table for at least one processing engine in at least one queue family when specific extensions are supported at a specific version:

Extension Extension specification version Operation name Operation version

VK_ARM_data_graph_instruction_set_tosa

1

TOSA.001000.1

0

Physical devices that support VK_ARM_data_graph_optical_flow must support the following VkPhysicalDeviceDataGraphOperationSupportARM for at least one processing engine in at least one queue family:

TOSA

The VkQueueFamilyDataGraphTOSAPropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph_instruction_set_tosa
typedef struct VkQueueFamilyDataGraphTOSAPropertiesARM {
    VkStructureType                         sType;
    void*                                   pNext;
    uint32_t                                profileCount;
    const VkDataGraphTOSANameQualityARM*    pProfiles;
    uint32_t                                extensionCount;
    const VkDataGraphTOSANameQualityARM*    pExtensions;
    VkDataGraphTOSALevelARM                 level;
} VkQueueFamilyDataGraphTOSAPropertiesARM;

  • sType is a VkStructureType value identifying this structure.

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

  • profileCount is the length of the pProfiles array.

  • pProfiles is a pointer to an array of VkDataGraphTOSANameQualityARM structures describing the TOSA profiles supported.

  • extensionCount is the length of the pExtensions array.

  • pExtensions is a pointer to an array of VkDataGraphTOSANameQualityARM structures describing the TOSA extensions supported.

  • level is a VkDataGraphTOSALevelARM describing the TOSA level supported.

Valid Usage (Implicit)

The VkDataGraphTOSANameQualityARM structure is defined as:

// Provided by VK_ARM_data_graph_instruction_set_tosa
typedef struct VkDataGraphTOSANameQualityARM {
    char                              name[VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM];
    VkDataGraphTOSAQualityFlagsARM    qualityFlags;
} VkDataGraphTOSANameQualityARM;

  • name is a pointer to a null-terminated UTF-8 string specifying the name of the TOSA profile or extension.

  • qualityLevel is a VkDataGraphTOSAQualityFlagsARM describing the quality of the support for the TOSA profile or extension.

VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM is the length in char values of an array containing the name of a data graph TOSA profile or extension, as returned in VkDataGraphTOSANameQualityARM::name.

#define VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM 128U

Bits which can be set in VkDataGraphTOSANameQualityARM::qualityLevel, describing the quality of a TOSA profile or extension, are:

// Provided by VK_ARM_data_graph_instruction_set_tosa
typedef enum VkDataGraphTOSAQualityFlagBitsARM {
    VK_DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM = 0x00000001,
    VK_DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM = 0x00000002,
    VK_DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM = 0x00000004,
    VK_DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM = 0x00000008,
} VkDataGraphTOSAQualityFlagBitsARM;
// Provided by VK_ARM_data_graph_instruction_set_tosa
typedef VkFlags   VkDataGraphTOSAQualityFlagsARM;

VkDataGraphTOSAQualityFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphTOSAQualityFlagBitsARM.

The defined data graph TOSA levels are:

// Provided by VK_ARM_data_graph_instruction_set_tosa
typedef enum VkDataGraphTOSALevelARM {
    VK_DATA_GRAPH_TOSA_LEVEL_NONE_ARM = 0,
    VK_DATA_GRAPH_TOSA_LEVEL_8K_ARM = 1,
} VkDataGraphTOSALevelARM;

Optical flow

An optical flow fixed-function node in a graph calculates the forward optical flow between an input image and a reference image. An output flow vector (Vx, Vy) means that current pixel (x, y) of the input image can be found at location (x+Vx, y+Vy) in the reference image.

An optical flow fixed function nodes have the following graph node connection points:

The VkQueueFamilyDataGraphOpticalFlowPropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkQueueFamilyDataGraphOpticalFlowPropertiesARM {
    VkStructureType                           sType;
    void*                                     pNext;
    VkDataGraphOpticalFlowGridSizeFlagsARM    supportedOutputGridSizes;
    VkDataGraphOpticalFlowGridSizeFlagsARM    supportedHintGridSizes;
    VkBool32                                  hintSupported;
    VkBool32                                  costSupported;
    uint32_t                                  minWidth;
    uint32_t                                  minHeight;
    uint32_t                                  maxWidth;
    uint32_t                                  maxHeight;
} VkQueueFamilyDataGraphOpticalFlowPropertiesARM;

  • sType is a VkStructureType value identifying this structure.

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

  • supportedOutputGridSizes are the supported VkDataGraphOpticalFlowGridSizeFlagsARM which can be specified in VkDataGraphPipelineOpticalFlowCreateInfoARM::outputGridSize.

  • supportedHintGridSizes are the supported VkDataGraphOpticalFlowGridSizeFlagsARM which can be specified in VkDataGraphPipelineOpticalFlowCreateInfoARM::hintGridSize.

  • hintSupported is a boolean describing whether using hint flow vector map is supported in an optical flow graph pipeline.

  • costSupported is a boolean describing whether cost map generation is supported in an optical flow graph pipeline.

  • minWidth is the minimum width in pixels for images used in an optical flow graph pipeline.

  • minHeight is the minimum height in pixels for images used in an optical flow graph pipeline.

  • maxWidth is the maximum width in pixels for images used in an optical flow graph pipeline.

  • maxHeight is the maximum height in pixels for images used in an optical flow graph pipeline.

Valid Usage (Implicit)

Image formats

To enumerate the supported image formats for a specific data graph optical flow usage, call:

// Provided by VK_ARM_data_graph_optical_flow
VkResult vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    const VkQueueFamilyDataGraphPropertiesARM*  pQueueFamilyDataGraphProperties,
    const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo,
    uint32_t*                                   pFormatCount,
    VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties);

  • physicalDevice is the physical device being queried.

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

  • pQueueFamilyDataGraphProperties is a pointer to a VkQueueFamilyDataGraphPropertiesARM structure that selects the processing engine and operation set for which the properties are queried.

  • pOpticalFlowImageFormatInfo is a pointer to a VkDataGraphOpticalFlowImageFormatInfoARM structure specifying the optical flow usage for which information is returned.

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

  • pImageFormatProperties is a pointer to an array of VkDataGraphOpticalFlowImageFormatPropertiesARM structures in which supported formats and image parameters are returned.

If pImageFormatProperties is NULL, then the number of optical flow properties supported for the given physicalDevice is returned in pFormatCount. Otherwise, pFormatCount must point to a variable set by the user to the number of elements in the pImageFormatProperties array, and on return the variable is overwritten with the number of values actually written to pImageFormatProperties. If the value of pFormatCount is less than the number of optical flow properties supported, at most pFormatCount values will be written to pImageFormatProperties, and VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available values were returned. Before creating an image to be used as a optical flow image, obtain the supported image creation parameters by querying with vkGetPhysicalDeviceFormatProperties2 and vkGetPhysicalDeviceImageFormatProperties2 using one of the reported formats and adding VkDataGraphOpticalFlowImageFormatInfoARM to the pNext chain of VkPhysicalDeviceImageFormatInfo2. When querying the parameters with vkGetPhysicalDeviceImageFormatProperties2 for images used for optical flow operations, the VkDataGraphOpticalFlowImageFormatInfoARM::usage field should contain one or more of the bits defined in VkDataGraphOpticalFlowImageUsageFlagBitsARM.

Valid Usage

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM-pQueueFamilyDataGraphProperties-09965
    pQueueFamilyDataGraphProperties must point to a structure whose operation member has its name member equal to OpticalFlow

Valid Usage (Implicit)

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

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM-pQueueFamilyDataGraphProperties-parameter
    pQueueFamilyDataGraphProperties must be a valid pointer to a valid VkQueueFamilyDataGraphPropertiesARM structure

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM-pOpticalFlowImageFormatInfo-parameter
    pOpticalFlowImageFormatInfo must be a valid pointer to a valid VkDataGraphOpticalFlowImageFormatInfoARM structure

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM-pFormatCount-parameter
    pFormatCount must be a valid pointer to a uint32_t value

  • VUID-vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM-pImageFormatProperties-parameter
    If the value referenced by pFormatCount is not 0, and pImageFormatProperties is not NULL, pImageFormatProperties must be a valid pointer to an array of pFormatCount VkDataGraphOpticalFlowImageFormatPropertiesARM structures

Return Codes
Success
Failure

VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8_UNORM, and VK_FORMAT_B10G11R11_UFLOAT_PACK32 are initially supported for images with optical flow usage VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM.

VK_FORMAT_R16G16_SFLOAT is initially supported for images with optical flow usage VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM and VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM.

VK_FORMAT_R16_UINT is initially supported for images with optical flow usage VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM.

The VkDataGraphOpticalFlowImageFormatInfoARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphOpticalFlowImageFormatInfoARM {
    VkStructureType                             sType;
    const void*                                 pNext;
    VkDataGraphOpticalFlowImageUsageFlagsARM    usage;
} VkDataGraphOpticalFlowImageFormatInfoARM;
Valid Usage (Implicit)
Structure Chaining
Extends the structures

Bits which can be set in VkDataGraphOpticalFlowImageFormatInfoARM::usage, controlling optical flow usage, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphOpticalFlowImageUsageFlagBitsARM {
    VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM = 0,
    VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM = 0x00000001,
    VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM = 0x00000002,
    VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM = 0x00000004,
    VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM = 0x00000008,
} VkDataGraphOpticalFlowImageUsageFlagBitsARM;
// Provided by VK_ARM_data_graph_optical_flow
typedef VkFlags   VkDataGraphOpticalFlowImageUsageFlagsARM;

VkDataGraphOpticalFlowImageUsageFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphOpticalFlowImageUsageFlagBitsARM.

The VkDataGraphOpticalFlowImageFormatPropertiesARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphOpticalFlowImageFormatPropertiesARM {
    VkStructureType    sType;
    void*              pNext;
    VkFormat           format;
} VkDataGraphOpticalFlowImageFormatPropertiesARM;

  • sType is a VkStructureType value identifying this structure.

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

  • format is a VkFormat that specifies the format that can be used with the specified optical flow image usages.

Valid Usage (Implicit)

Pipeline creation

The VkDataGraphPipelineOpticalFlowCreateInfoARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphPipelineOpticalFlowCreateInfoARM {
    VkStructureType                              sType;
    void*                                        pNext;
    uint32_t                                     width;
    uint32_t                                     height;
    VkFormat                                     imageFormat;
    VkFormat                                     flowVectorFormat;
    VkFormat                                     costFormat;
    VkDataGraphOpticalFlowGridSizeFlagsARM       outputGridSize;
    VkDataGraphOpticalFlowGridSizeFlagsARM       hintGridSize;
    VkDataGraphOpticalFlowPerformanceLevelARM    performanceLevel;
    VkDataGraphOpticalFlowCreateFlagsARM         flags;
} VkDataGraphPipelineOpticalFlowCreateInfoARM;

  • sType is a VkStructureType value identifying this structure.

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

  • width is the width in pixels of the input or reference image to be bound to this optical flow pipeline.

  • height is the height in pixels of the input or reference image to be bound to this optical flow pipeline.

  • imageFormat is the VkFormat of the input and reference image to be bound to this optical flow pipeline.

  • flowVectorFormat is the VkFormat of the flow vector maps (output or hint) to be bound to this optical flow pipeline.

  • costFormat is the VkFormat of the cost maps to be bound to this optical flow pipeline.

  • outputGridSize is exactly one bit of VkDataGraphOpticalFlowGridSizeFlagsARM specifying the grid size of the output flow and cost maps to be bound to this optical flow pipeline. The size of the output flow and cost maps is a function of the input image dimensions and outputGridSize and is calculated as follows:
    OutputWidth = ⌈ width / OutputGridWidth ⌉
    OutputHeight = ⌈ height / OutputGridHeight ⌉
    where OutputGridWidth and OutputGridHeight are determined by outputGridSize.

  • hintGridSize is one exactly bit of VkDataGraphOpticalFlowGridSizeFlagsARM specifying the grid size of the hint flow vector map to be bound to this optical flow pipeline. The size of the hint maps is a function of the input image dimensions and hintGridSize and is calculated as follows:
    HintWidth = ⌈ width / HintGridWidth ⌉
    HintHeight = ⌈ height / HintGridHeight ⌉
    where HintGridWidth and HintGridHeight are determined by hintGridSize.

  • performanceLevel is the VkDataGraphOpticalFlowPerformanceLevelARM used for this optical flow pipeline.

  • flags are the VkDataGraphOpticalFlowCreateFlagsARM used for this optical flow pipeline.

Valid Usage
Valid Usage (Implicit)

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-sType-sType
    sType must be VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-imageFormat-parameter
    imageFormat must be a valid VkFormat value

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-flowVectorFormat-parameter
    flowVectorFormat must be a valid VkFormat value

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-costFormat-parameter
    If costFormat is not 0, costFormat must be a valid VkFormat value

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-performanceLevel-parameter
    If performanceLevel is not 0, performanceLevel must be a valid VkDataGraphOpticalFlowPerformanceLevelARM value

  • VUID-VkDataGraphPipelineOpticalFlowCreateInfoARM-flags-parameter
    flags must be a valid combination of VkDataGraphOpticalFlowCreateFlagBitsARM values

Structure Chaining
Extends the structure

Optical flow vectors are generated block-wise, one vector for each block of NxN pixels (referred to as grid). Bits which can be set in VkDataGraphPipelineOpticalFlowCreateInfoARM::outputGridSize and VkDataGraphPipelineOpticalFlowCreateInfoARM::hintGridSize, or which are returned in VkQueueFamilyDataGraphOpticalFlowPropertiesARM::supportedOutputGridSizes and VkQueueFamilyDataGraphOpticalFlowPropertiesARM::supportedHintGridSizes controlling optical flow grid sizes, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphOpticalFlowGridSizeFlagBitsARM {
    VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM = 0,
    VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM = 0x00000001,
    VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM = 0x00000002,
    VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM = 0x00000004,
    VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM = 0x00000008,
} VkDataGraphOpticalFlowGridSizeFlagBitsARM;
// Provided by VK_ARM_data_graph_optical_flow
typedef VkFlags   VkDataGraphOpticalFlowGridSizeFlagsARM;

VkDataGraphOpticalFlowGridSizeFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphOpticalFlowGridSizeFlagBitsARM.

Optical flow exposes performance levels which the user can choose based on the desired performance and quality requirement. The optical flow performance level types are defined with the following:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphOpticalFlowPerformanceLevelARM {
    VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM = 0,
    VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM = 1,
    VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM = 2,
    VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM = 3,
} VkDataGraphOpticalFlowPerformanceLevelARM;

Bits which can be set in VkDataGraphPipelineOpticalFlowCreateInfoARM::flags, controlling optical flow pipeline operations, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphOpticalFlowCreateFlagBitsARM {
    VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM = 0x00000001,
    VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM = 0x00000002,
    VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM = 0x40000000,
} VkDataGraphOpticalFlowCreateFlagBitsARM;

VkDataGraphOpticalFlowCreateFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphOpticalFlowCreateFlagBitsARM.

// Provided by VK_ARM_data_graph_optical_flow
typedef VkFlags   VkDataGraphOpticalFlowCreateFlagsARM;

Pipeline dispatch

The VkDataGraphPipelineOpticalFlowDispatchInfoARM structure is defined as:

// Provided by VK_ARM_data_graph_optical_flow
typedef struct VkDataGraphPipelineOpticalFlowDispatchInfoARM {
    VkStructureType                          sType;
    void*                                    pNext;
    VkDataGraphOpticalFlowExecuteFlagsARM    flags;
    uint32_t                                 meanFlowL1NormHint;
} VkDataGraphPipelineOpticalFlowDispatchInfoARM;

  • sType is a VkStructureType value identifying this structure.

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

  • flags are the VkDataGraphOpticalFlowExecuteFlagsARM used for this command.

  • meanFlowL1NormHint is an integer used to hint to the implementation that the mean L1 norm of flow vectors is expected to be centered around this value (in number of pixels of the input image). The implementation may use this value to influence how flow vectors are computed. Different values may result in different flow vectors and will affect the cost of computing the flow vectors. A value of 0 means that the application does not wish to provide a hint.

Valid Usage
Valid Usage (Implicit)
Structure Chaining
Extends the structure

Bits which can be set in VkDataGraphPipelineOpticalFlowDispatchInfoARM::flags, controlling optical flow execution, are:

// Provided by VK_ARM_data_graph_optical_flow
typedef enum VkDataGraphOpticalFlowExecuteFlagBitsARM {
    VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM = 0x00000001,
    VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM = 0x00000002,
    VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM = 0x00000004,
    VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM = 0x00000008,
    VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM = 0x00000010,
} VkDataGraphOpticalFlowExecuteFlagBitsARM;

VkDataGraphOpticalFlowExecuteFlagsARM is a bitmask type for setting a mask of zero or more VkDataGraphOpticalFlowExecuteFlagBitsARM.

// Provided by VK_ARM_data_graph_optical_flow
typedef VkFlags   VkDataGraphOpticalFlowExecuteFlagsARM;