Graph Management(3)

NAME
Graph Management -

  Functions

cudaError_t cudaGraphAddChildGraphNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph)
Creates a child graph node and adds it to a graph.
cudaError_t cudaGraphAddDependencies (cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies)
Adds dependency edges to a graph.
cudaError_t cudaGraphAddEmptyNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies)
Creates an empty node and adds it to a graph.
cudaError_t cudaGraphAddHostNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams)
Creates a host execution node and adds it to a graph.
cudaError_t cudaGraphAddKernelNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams)
Creates a kernel execution node and adds it to a graph.
cudaError_t cudaGraphAddMemcpyNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams)
Creates a memcpy node and adds it to a graph.
cudaError_t cudaGraphAddMemsetNode (cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams)
Creates a memset node and adds it to a graph.
cudaError_t cudaGraphChildGraphNodeGetGraph (cudaGraphNode_t node, cudaGraph_t *pGraph)
Gets a handle to the embedded graph of a child graph node.
cudaError_t cudaGraphClone (cudaGraph_t *pGraphClone, cudaGraph_t originalGraph)
Clones a graph.
cudaError_t cudaGraphCreate (cudaGraph_t *pGraph, unsigned int flags)
Creates a graph.
cudaError_t cudaGraphDestroy (cudaGraph_t graph)
Destroys a graph.
cudaError_t cudaGraphDestroyNode (cudaGraphNode_t node)
Remove a node from the graph.
cudaError_t cudaGraphExecDestroy (cudaGraphExec_t graphExec)
Destroys an executable graph.
cudaError_t cudaGraphExecHostNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams)
Sets the parameters for a host node in the given graphExec.
cudaError_t cudaGraphExecKernelNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams)
Sets the parameters for a kernel node in the given graphExec.
cudaError_t cudaGraphExecMemcpyNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams)
Sets the parameters for a memcpy node in the given graphExec.
cudaError_t cudaGraphExecMemsetNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams)
Sets the parameters for a memset node in the given graphExec.
cudaError_t cudaGraphExecUpdate (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out)
Check whether an executable graph can be updated with a graph and perform the update if possible.
cudaError_t cudaGraphGetEdges (cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges)
Returns a graph's dependency edges.
cudaError_t cudaGraphGetNodes (cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes)
Returns a graph's nodes.
cudaError_t cudaGraphGetRootNodes (cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes)
Returns a graph's root nodes.
cudaError_t cudaGraphHostNodeGetParams (cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams)
Returns a host node's parameters.
cudaError_t cudaGraphHostNodeSetParams (cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams)
Sets a host node's parameters.
cudaError_t cudaGraphInstantiate (cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize)
Creates an executable graph from a graph.
cudaError_t cudaGraphKernelNodeCopyAttributes (cudaGraphNode_t hSrc, cudaGraphNode_t hDst)
Copies attributes from source node to destination node.
cudaError_t cudaGraphKernelNodeGetAttribute (cudaGraphNode_t hNode, enum cudaKernelNodeAttrID attr, union cudaKernelNodeAttrValue *value_out)
Queries node attribute.
cudaError_t cudaGraphKernelNodeGetParams (cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams)
Returns a kernel node's parameters.
cudaError_t cudaGraphKernelNodeSetAttribute (cudaGraphNode_t hNode, enum cudaKernelNodeAttrID attr, const union cudaKernelNodeAttrValue *value)
Sets node attribute.
cudaError_t cudaGraphKernelNodeSetParams (cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams)
Sets a kernel node's parameters.
cudaError_t cudaGraphLaunch (cudaGraphExec_t graphExec, cudaStream_t stream)
Launches an executable graph in a stream.
cudaError_t cudaGraphMemcpyNodeGetParams (cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams)
Returns a memcpy node's parameters.
cudaError_t cudaGraphMemcpyNodeSetParams (cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams)
Sets a memcpy node's parameters.
cudaError_t cudaGraphMemsetNodeGetParams (cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams)
Returns a memset node's parameters.
cudaError_t cudaGraphMemsetNodeSetParams (cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams)
Sets a memset node's parameters.
cudaError_t cudaGraphNodeFindInClone (cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph)
Finds a cloned version of a node.
cudaError_t cudaGraphNodeGetDependencies (cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies)
Returns a node's dependencies.
cudaError_t cudaGraphNodeGetDependentNodes (cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes)
Returns a node's dependent nodes.
cudaError_t cudaGraphNodeGetType (cudaGraphNode_t node, enum cudaGraphNodeType *pType)
Returns a node's type.
cudaError_t cudaGraphRemoveDependencies (cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies)
Removes dependency edges from a graph.

Detailed Description

\brief graph management functions of the CUDA runtime API (cuda_runtime_api.h)

This section describes the graph management functions of CUDA runtime application programming interface.

Function Documentation

  cudaError_t cudaGraphAddChildGraphNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraph_t childGraph)

Creates a new node which executes an embedded graph, and adds it to graph with numDependencies dependencies specified via pDependencies. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

The node executes an embedded child graph. The child graph is cloned in this call.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies
    childGraph - The graph to clone into this node

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphChildGraphNodeGetGraph, cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode, cudaGraphClone

  cudaError_t cudaGraphAddDependencies (cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies)

The number of dependencies to be added is defined by numDependencies Elements in pFrom and pTo at corresponding indices define a dependency. Each node in pFrom and pTo must belong to graph.

If numDependencies is 0, elements in pFrom and pTo will be ignored. Specifying an existing dependency will return an error.

Parameters:
    graph - Graph to which dependencies are added
    from - Array of nodes that provide the dependencies
    to - Array of dependent nodes
    numDependencies - Number of dependencies to be added

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphRemoveDependencies, cudaGraphGetEdges, cudaGraphNodeGetDependencies, cudaGraphNodeGetDependentNodes

  cudaError_t cudaGraphAddEmptyNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies)

Creates a new node which performs no operation, and adds it to graph with numDependencies dependencies specified via pDependencies. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

An empty node performs no operation during execution, but can be used for transitive ordering. For example, a phased execution graph with 2 groups of n nodes with a barrier between them can be represented using an empty node and 2*n dependency edges, rather than no empty node and n^2 dependency edges.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

See also:
    cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddChildGraphNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode

  cudaError_t cudaGraphAddHostNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const struct cudaHostNodeParams * pNodeParams)

Creates a new CPU execution node and adds it to graph with numDependencies dependencies specified via pDependencies and arguments specified in pNodeParams. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

When the graph is launched, the node will invoke the specified CPU function. Host nodes are not supported under MPS with pre-Volta GPUs.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies
    pNodeParams - Parameters for the host node

Returns:
    cudaSuccess, cudaErrorNotSupported, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchHostFunc, cudaGraphHostNodeGetParams, cudaGraphHostNodeSetParams, cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode

  cudaError_t cudaGraphAddKernelNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const struct cudaKernelNodeParams * pNodeParams)

Creates a new kernel execution node and adds it to graph with numDependencies dependencies specified via pDependencies and arguments specified in pNodeParams. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

The cudaKernelNodeParams structure is defined as:

  struct cudaKernelNodeParams
  {
      void* func;
      dim3 gridDim;
      dim3 blockDim;
      unsigned int sharedMemBytes;
      void **kernelParams;
      void **extra;
  };

When the graph is launched, the node will invoke kernel func on a (gridDim.x x gridDim.y x gridDim.z) grid of blocks. Each block contains (blockDim.x x blockDim.y x blockDim.z) threads.

sharedMem sets the amount of dynamic shared memory that will be available to each thread block.

Kernel parameters to func can be specified in one of two ways:

1) Kernel parameters can be specified via kernelParams. If the kernel has N parameters, then kernelParams needs to be an array of N pointers. Each pointer, from kernelParams[0] to kernelParams[N-1], points to the region of memory from which the actual parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image.

2) Kernel parameters can also be packaged by the application into a single buffer that is passed in via extra. This places the burden on the application of knowing each kernel parameter's size and alignment/padding within the buffer. The extra parameter exists to allow this function to take additional less commonly used arguments. extra specifies a list of names of extra settings and their corresponding values. Each extra setting name is immediately followed by the corresponding value. The list must be terminated with either NULL or CU_LAUNCH_PARAM_END.

•   CU_LAUNCH_PARAM_END, which indicates the end of the extra array;

•   CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next value in extra will be a pointer to a buffer containing all the kernel parameters for launching kernel func;

•   CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next value in extra will be a pointer to a size_t containing the size of the buffer specified with CU_LAUNCH_PARAM_BUFFER_POINTER;

The error cudaErrorInvalidValue will be returned if kernel parameters are specified with both kernelParams and extra (i.e. both kernelParams and extra are non-NULL).

The kernelParams or extra array, as well as the argument values it points to, are copied during this call.

Note:
    Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies
    pNodeParams - Parameters for the GPU execution node

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDeviceFunction

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchKernel, cudaGraphKernelNodeGetParams, cudaGraphKernelNodeSetParams, cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode

  cudaError_t cudaGraphAddMemcpyNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms * pCopyParams)

Creates a new memcpy node and adds it to graph with numDependencies dependencies specified via pDependencies. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

When the graph is launched, the node will perform the memcpy described by pCopyParams. See cudaMemcpy3D() for a description of the structure and its restrictions.

Memcpy nodes have some additional restrictions with regards to managed memory, if the system contains at least one device which has a zero value for the device attribute cudaDevAttrConcurrentManagedAccess.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies
    pCopyParams - Parameters for the memory copy

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemcpy3D, cudaGraphMemcpyNodeGetParams, cudaGraphMemcpyNodeSetParams, cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemsetNode

  cudaError_t cudaGraphAddMemsetNode (cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const struct cudaMemsetParams * pMemsetParams)

Creates a new memset node and adds it to graph with numDependencies dependencies specified via pDependencies. It is possible for numDependencies to be 0, in which case the node will be placed at the root of the graph. pDependencies may not have any duplicate entries. A handle to the new node will be returned in pGraphNode.

The element size must be 1, 2, or 4 bytes. When the graph is launched, the node will perform the memset described by pMemsetParams.

Parameters:
    pGraphNode - Returns newly created node
    graph - Graph to which to add the node
    pDependencies - Dependencies of the node
    numDependencies - Number of dependencies
    pMemsetParams - Parameters for the memory set

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemset2D, cudaGraphMemsetNodeGetParams, cudaGraphMemsetNodeSetParams, cudaGraphCreate, cudaGraphDestroyNode, cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode

  cudaError_t cudaGraphChildGraphNodeGetGraph (cudaGraphNode_t node, cudaGraph_t * pGraph)

Gets a handle to the embedded graph in a child graph node. This call does not clone the graph. Changes to the graph will be reflected in the node, and the node retains ownership of the graph.

Parameters:
    node - Node to get the embedded graph for
    pGraph - Location to store a handle to the graph

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddChildGraphNode, cudaGraphNodeFindInClone

  cudaError_t cudaGraphClone (cudaGraph_t * pGraphClone, cudaGraph_t originalGraph)

This function creates a copy of originalGraph and returns it in pGraphClone. All parameters are copied into the cloned graph. The original graph may be modified after this call without affecting the clone.

Child graph nodes in the original graph are recursively copied into the clone.

Parameters:
    pGraphClone - Returns newly created cloned graph
    originalGraph - Graph to clone

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphCreate, cudaGraphNodeFindInClone

  cudaError_t cudaGraphCreate (cudaGraph_t * pGraph, unsigned int flags)

Creates an empty graph, which is returned via pGraph.

Parameters:
    pGraph - Returns newly created graph
    flags - Graph creation flags, must be 0

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode, cudaGraphInstantiate, cudaGraphDestroy, cudaGraphGetNodes, cudaGraphGetRootNodes, cudaGraphGetEdges, cudaGraphClone

  cudaError_t cudaGraphDestroy (cudaGraph_t graph)

Destroys the graph specified by graph, as well as all of its nodes.

Parameters:
    graph - Graph to destroy

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphCreate

  cudaError_t cudaGraphDestroyNode (cudaGraphNode_t node)

Removes node from its graph. This operation also severs any dependencies of other nodes on node and vice versa.

Parameters:
    node - Node to remove

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddChildGraphNode, cudaGraphAddEmptyNode, cudaGraphAddKernelNode, cudaGraphAddHostNode, cudaGraphAddMemcpyNode, cudaGraphAddMemsetNode

  cudaError_t cudaGraphExecDestroy (cudaGraphExec_t graphExec)

Destroys the executable graph specified by graphExec.

Parameters:
    graphExec - Executable graph to destroy

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphInstantiate, cudaGraphLaunch

  cudaError_t cudaGraphExecHostNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams * pNodeParams)

Updates the work represented by node in hGraphExec as though node had contained pNodeParams at instantiation. node must remain in the graph which was used to instantiate hGraphExec. Changed edges to and from node are ignored.

The modifications only affect future launches of hGraphExec. Already enqueued or running launches of hGraphExec are not affected by this call. node is also not modified by this call.

Parameters:
    hGraphExec - The executable graph in which to set the specified node
    node - Host node from the graph which was used to instantiate graphExec
    pNodeParams - Updated Parameters to set

Returns:
    cudaSuccess, cudaErrorInvalidValue,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddHostNode, cudaGraphHostNodeSetParams cudaGraphInstantiate cudaGraphExecKernelNodeSetParams cudaGraphExecMemcpyNodeSetParams cudaGraphExecMemsetNodeSetParams

  cudaError_t cudaGraphExecKernelNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams * pNodeParams)

Sets the parameters of a kernel node in an executable graph hGraphExec. The node is identified by the corresponding node node in the non-executable graph, from which the executable graph was instantiated.

node must not have been removed from the original graph. The func field of nodeParams cannot be modified and must match the original value. All other values can be modified.

The modifications only affect future launches of hGraphExec. Already enqueued or running launches of hGraphExec are not affected by this call. node is also not modified by this call.

Parameters:
    hGraphExec - The executable graph in which to set the specified node
    node - kernel node from the graph from which graphExec was instantiated
    pNodeParams - Updated Parameters to set

Returns:
    cudaSuccess, cudaErrorInvalidValue,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddKernelNode, cudaGraphKernelNodeSetParams, cudaGraphInstantiate

  cudaError_t cudaGraphExecMemcpyNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms * pNodeParams)

Updates the work represented by node in hGraphExec as though node had contained pNodeParams at instantiation. node must remain in the graph which was used to instantiate hGraphExec. Changed edges to and from node are ignored.

The source and destination memory in pNodeParams must be allocated from the same contexts as the original source and destination memory. Both the instantiation-time memory operands and the memory operands in pNodeParams must be 1-dimensional. Zero-length operations are not supported.

The modifications only affect future launches of hGraphExec. Already enqueued or running launches of hGraphExec are not affected by this call. node is also not modified by this call.

Returns cudaErrorInvalidValue if the memory operands' mappings changed or either the original or new memory operands are multidimensional.

Parameters:
    hGraphExec - The executable graph in which to set the specified node
    nodei - Memcpy node from the graph which was used to instantiate graphExec
    pNodeParams - Updated Parameters to set

Returns:
    cudaSuccess, cudaErrorInvalidValue,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddMemcpyNode, cudaGraphMemcpyNodeSetParams cudaGraphInstantiate cudaGraphExecKernelNodeSetParams cudaGraphExecMemsetNodeSetParams cudaGraphExecHostNodeSetParams

  cudaError_t cudaGraphExecMemsetNodeSetParams (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams * pNodeParams)

Updates the work represented by node in hGraphExec as though node had contained pNodeParams at instantiation. node must remain in the graph which was used to instantiate hGraphExec. Changed edges to and from node are ignored.

The destination memory in pNodeParams must be allocated from the same context as the original destination memory. Both the instantiation-time memory operand and the memory operand in pNodeParams must be 1-dimensional. Zero-length operations are not supported.

The modifications only affect future launches of hGraphExec. Already enqueued or running launches of hGraphExec are not affected by this call. node is also not modified by this call.

Returns cudaErrorInvalidValue if the memory operand's mappings changed or either the original or new memory operand are multidimensional.

Parameters:
    hGraphExec - The executable graph in which to set the specified node
    node - Memset node from the graph which was used to instantiate graphExec
    pNodeParams - Updated Parameters to set

Returns:
    cudaSuccess, cudaErrorInvalidValue,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddMemsetNode, cudaGraphMemsetNodeSetParams cudaGraphInstantiate cudaGraphExecKernelNodeSetParams cudaGraphExecMemcpyNodeSetParams cudaGraphExecHostNodeSetParams

  cudaError_t cudaGraphExecUpdate (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t * hErrorNode_out, enum cudaGraphExecUpdateResult * updateResult_out)

Updates the node parameters in the instantiated graph specified by hGraphExec with the node parameters in a topologically identical graph specified by hGraph.

Limitations:

•   Kernel nodes:

•   The function must not change (same restriction as cudaGraphExecKernelNodeSetParams())

•   Memset and memcpy nodes:

•   The CUDA device(s) to which the operand(s) was allocated/mapped cannot change.

•   The source/destination memory must be allocated from the same contexts as the original source/destination memory.

•   Only 1D memsets can be changed.

•   Additional memcpy node restrictions:

•   Changing either the source or destination memory type(i.e. CU_MEMORYTYPE_DEVICE, CU_MEMORYTYPE_ARRAY, etc.) is not supported.

Note: The API may add further restrictions in future releases. The return code should always be checked.

Some node types are not currently supported:

•   Empty graph nodes(cudaGraphNodeTypeEmpty)

•   Child graphs(cudaGraphNodeTypeGraph).

cudaGraphExecUpdate sets updateResult_out to cudaGraphExecUpdateErrorTopologyChanged under the following conditions:

•   The count of nodes directly in hGraphExec and hGraph differ, in which case hErrorNode_out is NULL.

•   A node is deleted in hGraph but not not its pair from hGraphExec, in which case hErrorNode_out is NULL.

•   A node is deleted in hGraphExec but not its pair from hGraph, in which case hErrorNode_out is the pairless node from hGraph.

•   The dependent nodes of a pair differ, in which case hErrorNode_out is the node from hGraph.

cudaGraphExecUpdate sets updateResult_out to:

•   cudaGraphExecUpdateError if passed an invalid value.

•   cudaGraphExecUpdateErrorTopologyChanged if the graph topology changed

•   cudaGraphExecUpdateErrorNodeTypeChanged if the type of a node changed, in which case hErrorNode_out is set to the node from hGraph.

•   cudaGraphExecUpdateErrorFunctionChanged if the func field of a kernel changed, in which case hErrorNode_out is set to the node from hGraph

•   cudaGraphExecUpdateErrorParametersChanged if any parameters to a node changed in a way that is not supported, in which case hErrorNode_out is set to the node from hGraph

•   cudaGraphExecUpdateErrorNotSupported if something about a node is unsupported, like the node's type or configuration, in which case hErrorNode_out is set to the node from hGraph

If updateResult_out isn't set in one of the situations described above, the update check passes and cudaGraphExecUpdate updates hGraphExec to match the contents of hGraph. If an error happens during the update, updateResult_out will be set to cudaGraphExecUpdateError; otherwise, updateResult_out is set to cudaGraphExecUpdateSuccess.

cudaGraphExecUpdate returns cudaSuccess when the updated was performed successfully. It returns cudaErrorGraphExecUpdateFailure if the graph update was not performed because it included changes which violated constraints specific to instantiated graph update.

Parameters:
    hGraphExec The instantiated graph to be updated
    hGraph The graph containing the updated parameters
    hErrorNode_out The node which caused the permissibility check to forbid the update, if any
    updateResult_out Whether the graph update was permitted. If was forbidden, the reason why

Returns:
    cudaSuccess, cudaErrorGraphExecUpdateFailure,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphInstantiate,

  cudaError_t cudaGraphGetEdges (cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, size_t * numEdges)

Returns a list of graph's dependency edges. Edges are returned via corresponding indices in from and to; that is, the node in to[i] has a dependency on the node in from[i]. from and to may both be NULL, in which case this function only returns the number of edges in numEdges. Otherwise, numEdges entries will be filled in. If numEdges is higher than the actual number of edges, the remaining entries in from and to will be set to NULL, and the number of edges actually returned will be written to numEdges.

Parameters:
    graph - Graph to get the edges from
    from - Location to return edge endpoints
    to - Location to return edge endpoints
    numEdges - See description

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphGetNodes, cudaGraphGetRootNodes, cudaGraphAddDependencies, cudaGraphRemoveDependencies, cudaGraphNodeGetDependencies, cudaGraphNodeGetDependentNodes

  cudaError_t cudaGraphGetNodes (cudaGraph_t graph, cudaGraphNode_t * nodes, size_t * numNodes)

Returns a list of graph's nodes. nodes may be NULL, in which case this function will return the number of nodes in numNodes. Otherwise, numNodes entries will be filled in. If numNodes is higher than the actual number of nodes, the remaining entries in nodes will be set to NULL, and the number of nodes actually obtained will be returned in numNodes.

Parameters:
    graph - Graph to query
    nodes - Pointer to return the nodes
    numNodes - See description

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphCreate, cudaGraphGetRootNodes, cudaGraphGetEdges, cudaGraphNodeGetType, cudaGraphNodeGetDependencies, cudaGraphNodeGetDependentNodes

  cudaError_t cudaGraphGetRootNodes (cudaGraph_t graph, cudaGraphNode_t * pRootNodes, size_t * pNumRootNodes)

Returns a list of graph's root nodes. pRootNodes may be NULL, in which case this function will return the number of root nodes in pNumRootNodes. Otherwise, pNumRootNodes entries will be filled in. If pNumRootNodes is higher than the actual number of root nodes, the remaining entries in pRootNodes will be set to NULL, and the number of nodes actually obtained will be returned in pNumRootNodes.

Parameters:
    graph - Graph to query
    pRootNodes - Pointer to return the root nodes
    pNumRootNodes - See description

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphCreate, cudaGraphGetNodes, cudaGraphGetEdges, cudaGraphNodeGetType, cudaGraphNodeGetDependencies, cudaGraphNodeGetDependentNodes

  cudaError_t cudaGraphHostNodeGetParams (cudaGraphNode_t node, struct cudaHostNodeParams * pNodeParams)

Returns the parameters of host node node in pNodeParams.

Parameters:
    node - Node to get the parameters for
    pNodeParams - Pointer to return the parameters

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchHostFunc, cudaGraphAddHostNode, cudaGraphHostNodeSetParams

  cudaError_t cudaGraphHostNodeSetParams (cudaGraphNode_t node, const struct cudaHostNodeParams * pNodeParams)

Sets the parameters of host node node to nodeParams.

Parameters:
    node - Node to set the parameters for
    pNodeParams - Parameters to copy

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchHostFunc, cudaGraphAddHostNode, cudaGraphHostNodeGetParams

  cudaError_t cudaGraphInstantiate (cudaGraphExec_t * pGraphExec, cudaGraph_t graph, cudaGraphNode_t * pErrorNode, char * pLogBuffer, size_t bufferSize)

Instantiates graph as an executable graph. The graph is validated for any structural constraints or intra-node constraints which were not previously validated. If instantiation is successful, a handle to the instantiated graph is returned in pGraphExec.

If there are any errors, diagnostic information may be returned in pErrorNode and pLogBuffer. This is the primary way to inspect instantiation errors. The output will be null terminated unless the diagnostics overflow the buffer. In this case, they will be truncated, and the last byte can be inspected to determine if truncation occurred.

Parameters:
    pGraphExec - Returns instantiated graph
    graph - Graph to instantiate
    pErrorNode - In case of an instantiation error, this may be modified to indicate a node contributing to the error
    pLogBuffer - A character buffer to store diagnostic messages
    bufferSize - Size of the log buffer in bytes

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphCreate, cudaGraphLaunch, cudaGraphExecDestroy

  cudaError_t cudaGraphKernelNodeCopyAttributes (cudaGraphNode_t hSrc, cudaGraphNode_t hDst)

Copies attributes from source node src to destination node dst. Both node must have the same context.

Parameters:
    dst Destination node
    src Source node For list of attributes see cudaKernelNodeAttrID

Returns:
    cudaSuccess, cudaErrorInvalidContext

Note:
    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaAccessPolicyWindow

  cudaError_t cudaGraphKernelNodeGetAttribute (cudaGraphNode_t hNode, enum cudaKernelNodeAttrID attr, union cudaKernelNodeAttrValue * value_out)

Queries attribute attr from node hNode and stores it in corresponding member of value_out.

Parameters:
    hNode
    attr
    value_out

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle

Note:
    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaAccessPolicyWindow

  cudaError_t cudaGraphKernelNodeGetParams (cudaGraphNode_t node, struct cudaKernelNodeParams * pNodeParams)

Returns the parameters of kernel node node in pNodeParams. The kernelParams or extra array returned in pNodeParams, as well as the argument values it points to, are owned by the node. This memory remains valid until the node is destroyed or its parameters are modified, and should not be modified directly. Use cudaGraphKernelNodeSetParams to update the parameters of this node.

The params will contain either kernelParams or extra, according to which of these was most recently set on the node.

Parameters:
    node - Node to get the parameters for
    pNodeParams - Pointer to return the parameters

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDeviceFunction

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchKernel, cudaGraphAddKernelNode, cudaGraphKernelNodeSetParams

  cudaError_t cudaGraphKernelNodeSetAttribute (cudaGraphNode_t hNode, enum cudaKernelNodeAttrID attr, const union cudaKernelNodeAttrValue * value)

Sets attribute attr on node hNode from corresponding attribute of value.

Parameters:
    hNode
    attr
    value

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle

Note:
    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaAccessPolicyWindow

  cudaError_t cudaGraphKernelNodeSetParams (cudaGraphNode_t node, const struct cudaKernelNodeParams * pNodeParams)

Sets the parameters of kernel node node to pNodeParams.

Parameters:
    node - Node to set the parameters for
    pNodeParams - Parameters to copy

Returns:
    cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorMemoryAllocation

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaLaunchKernel, cudaGraphAddKernelNode, cudaGraphKernelNodeGetParams

  cudaError_t cudaGraphLaunch (cudaGraphExec_t graphExec, cudaStream_t stream)

Executes graphExec in stream. Only one instance of graphExec may be executing at a time. Each launch is ordered behind both any previous work in stream and any previous launches of graphExec. To execute a graph concurrently, it must be instantiated multiple times into multiple executable graphs.

Parameters:
    graphExec - Executable graph to launch
    stream - Stream in which to launch the graph

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphInstantiate, cudaGraphExecDestroy

  cudaError_t cudaGraphMemcpyNodeGetParams (cudaGraphNode_t node, struct cudaMemcpy3DParms * pNodeParams)

Returns the parameters of memcpy node node in pNodeParams.

Parameters:
    node - Node to get the parameters for
    pNodeParams - Pointer to return the parameters

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemcpy3D, cudaGraphAddMemcpyNode, cudaGraphMemcpyNodeSetParams

  cudaError_t cudaGraphMemcpyNodeSetParams (cudaGraphNode_t node, const struct cudaMemcpy3DParms * pNodeParams)

Sets the parameters of memcpy node node to pNodeParams.

Parameters:
    node - Node to set the parameters for
    pNodeParams - Parameters to copy

Returns:
    cudaSuccess, cudaErrorInvalidValue,

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemcpy3D, cudaGraphAddMemcpyNode, cudaGraphMemcpyNodeGetParams

  cudaError_t cudaGraphMemsetNodeGetParams (cudaGraphNode_t node, struct cudaMemsetParams * pNodeParams)

Returns the parameters of memset node node in pNodeParams.

Parameters:
    node - Node to get the parameters for
    pNodeParams - Pointer to return the parameters

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemset2D, cudaGraphAddMemsetNode, cudaGraphMemsetNodeSetParams

  cudaError_t cudaGraphMemsetNodeSetParams (cudaGraphNode_t node, const struct cudaMemsetParams * pNodeParams)

Sets the parameters of memset node node to pNodeParams.

Parameters:
    node - Node to set the parameters for
    pNodeParams - Parameters to copy

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaMemset2D, cudaGraphAddMemsetNode, cudaGraphMemsetNodeGetParams

  cudaError_t cudaGraphNodeFindInClone (cudaGraphNode_t * pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph)

This function returns the node in clonedGraph corresponding to originalNode in the original graph.

clonedGraph must have been cloned from originalGraph via cudaGraphClone. originalNode must have been in originalGraph at the time of the call to cudaGraphClone, and the corresponding cloned node in clonedGraph must not have been removed. The cloned node is then returned via pClonedNode.

Parameters:
    pNode - Returns handle to the cloned node
    originalNode - Handle to the original node
    clonedGraph - Cloned graph to query

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphClone

  cudaError_t cudaGraphNodeGetDependencies (cudaGraphNode_t node, cudaGraphNode_t * pDependencies, size_t * pNumDependencies)

Returns a list of node's dependencies. pDependencies may be NULL, in which case this function will return the number of dependencies in pNumDependencies. Otherwise, pNumDependencies entries will be filled in. If pNumDependencies is higher than the actual number of dependencies, the remaining entries in pDependencies will be set to NULL, and the number of nodes actually obtained will be returned in pNumDependencies.

Parameters:
    node - Node to query
    pDependencies - Pointer to return the dependencies
    pNumDependencies - See description

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphNodeGetDependentNodes, cudaGraphGetNodes, cudaGraphGetRootNodes, cudaGraphGetEdges, cudaGraphAddDependencies, cudaGraphRemoveDependencies

  cudaError_t cudaGraphNodeGetDependentNodes (cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, size_t * pNumDependentNodes)

Returns a list of node's dependent nodes. pDependentNodes may be NULL, in which case this function will return the number of dependent nodes in pNumDependentNodes. Otherwise, pNumDependentNodes entries will be filled in. If pNumDependentNodes is higher than the actual number of dependent nodes, the remaining entries in pDependentNodes will be set to NULL, and the number of nodes actually obtained will be returned in pNumDependentNodes.

Parameters:
    node - Node to query
    pDependentNodes - Pointer to return the dependent nodes
    pNumDependentNodes - See description

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphNodeGetDependencies, cudaGraphGetNodes, cudaGraphGetRootNodes, cudaGraphGetEdges, cudaGraphAddDependencies, cudaGraphRemoveDependencies

  cudaError_t cudaGraphNodeGetType (cudaGraphNode_t node, enum cudaGraphNodeType * pType)

Returns the node type of node in pType.

Parameters:
    node - Node to query
    pType - Pointer to return the node type

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphGetNodes, cudaGraphGetRootNodes, cudaGraphChildGraphNodeGetGraph, cudaGraphKernelNodeGetParams, cudaGraphKernelNodeSetParams, cudaGraphHostNodeGetParams, cudaGraphHostNodeSetParams, cudaGraphMemcpyNodeGetParams, cudaGraphMemcpyNodeSetParams, cudaGraphMemsetNodeGetParams, cudaGraphMemsetNodeSetParams

  cudaError_t cudaGraphRemoveDependencies (cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies)

The number of pDependencies to be removed is defined by numDependencies. Elements in pFrom and pTo at corresponding indices define a dependency. Each node in pFrom and pTo must belong to graph.

If numDependencies is 0, elements in pFrom and pTo will be ignored. Specifying a non-existing dependency will return an error.

Parameters:
    graph - Graph from which to remove dependencies
    from - Array of nodes that provide the dependencies
    to - Array of dependent nodes
    numDependencies - Number of dependencies to be removed

Returns:
    cudaSuccess, cudaErrorInvalidValue

Note:
    Graph objects are not threadsafe. .

    Note that this function may also return error codes from previous, asynchronous launches.

See also:
    cudaGraphAddDependencies, cudaGraphGetEdges, cudaGraphNodeGetDependencies, cudaGraphNodeGetDependentNodes

Author

Generated automatically by Doxygen from the source code.