Provided by: nvidia-cuda-dev_10.1.243-3_amd64 
NAME
Graph Management -
Functions
CUresult cuGraphAddChildGraphNode (CUgraphNode *phGraphNode, CUgraph hGraph, const
CUgraphNode *dependencies, size_t numDependencies, CUgraph childGraph)
Creates a child graph node and adds it to a graph.
CUresult cuGraphAddDependencies (CUgraph hGraph, const CUgraphNode *from, const
CUgraphNode *to, size_t numDependencies)
Adds dependency edges to a graph.
CUresult cuGraphAddEmptyNode (CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode
*dependencies, size_t numDependencies)
Creates an empty node and adds it to a graph.
CUresult cuGraphAddHostNode (CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode
*dependencies, size_t numDependencies, const CUDA_HOST_NODE_PARAMS *nodeParams)
Creates a host execution node and adds it to a graph.
CUresult cuGraphAddKernelNode (CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode
*dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS *nodeParams)
Creates a kernel execution node and adds it to a graph.
CUresult cuGraphAddMemcpyNode (CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode
*dependencies, size_t numDependencies, const CUDA_MEMCPY3D *copyParams, CUcontext ctx)
Creates a memcpy node and adds it to a graph.
CUresult cuGraphAddMemsetNode (CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode
*dependencies, size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS *memsetParams,
CUcontext ctx)
Creates a memset node and adds it to a graph.
CUresult cuGraphChildGraphNodeGetGraph (CUgraphNode hNode, CUgraph *phGraph)
Gets a handle to the embedded graph of a child graph node.
CUresult cuGraphClone (CUgraph *phGraphClone, CUgraph originalGraph)
Clones a graph.
CUresult cuGraphCreate (CUgraph *phGraph, unsigned int flags)
Creates a graph.
CUresult cuGraphDestroy (CUgraph hGraph)
Destroys a graph.
CUresult cuGraphDestroyNode (CUgraphNode hNode)
Remove a node from the graph.
CUresult cuGraphExecDestroy (CUgraphExec hGraphExec)
Destroys an executable graph.
CUresult cuGraphExecKernelNodeSetParams (CUgraphExec hGraphExec, CUgraphNode hNode, const
CUDA_KERNEL_NODE_PARAMS *nodeParams)
Sets the parameters for a kernel node in the given graphExec.
CUresult cuGraphGetEdges (CUgraph hGraph, CUgraphNode *from, CUgraphNode *to, size_t
*numEdges)
Returns a graph's dependency edges.
CUresult cuGraphGetNodes (CUgraph hGraph, CUgraphNode *nodes, size_t *numNodes)
Returns a graph's nodes.
CUresult cuGraphGetRootNodes (CUgraph hGraph, CUgraphNode *rootNodes, size_t
*numRootNodes)
Returns a graph's root nodes.
CUresult cuGraphHostNodeGetParams (CUgraphNode hNode, CUDA_HOST_NODE_PARAMS *nodeParams)
Returns a host node's parameters.
CUresult cuGraphHostNodeSetParams (CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS
*nodeParams)
Sets a host node's parameters.
CUresult cuGraphInstantiate (CUgraphExec *phGraphExec, CUgraph hGraph, CUgraphNode
*phErrorNode, char *logBuffer, size_t bufferSize)
Creates an executable graph from a graph.
CUresult cuGraphKernelNodeGetParams (CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS
*nodeParams)
Returns a kernel node's parameters.
CUresult cuGraphKernelNodeSetParams (CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS
*nodeParams)
Sets a kernel node's parameters.
CUresult cuGraphLaunch (CUgraphExec hGraphExec, CUstream hStream)
Launches an executable graph in a stream.
CUresult cuGraphMemcpyNodeGetParams (CUgraphNode hNode, CUDA_MEMCPY3D *nodeParams)
Returns a memcpy node's parameters.
CUresult cuGraphMemcpyNodeSetParams (CUgraphNode hNode, const CUDA_MEMCPY3D *nodeParams)
Sets a memcpy node's parameters.
CUresult cuGraphMemsetNodeGetParams (CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS
*nodeParams)
Returns a memset node's parameters.
CUresult cuGraphMemsetNodeSetParams (CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS
*nodeParams)
Sets a memset node's parameters.
CUresult cuGraphNodeFindInClone (CUgraphNode *phNode, CUgraphNode hOriginalNode, CUgraph
hClonedGraph)
Finds a cloned version of a node.
CUresult cuGraphNodeGetDependencies (CUgraphNode hNode, CUgraphNode *dependencies, size_t
*numDependencies)
Returns a node's dependencies.
CUresult cuGraphNodeGetDependentNodes (CUgraphNode hNode, CUgraphNode *dependentNodes,
size_t *numDependentNodes)
Returns a node's dependent nodes.
CUresult cuGraphNodeGetType (CUgraphNode hNode, CUgraphNodeType *type)
Returns a node's type.
CUresult cuGraphRemoveDependencies (CUgraph hGraph, const CUgraphNode *from, const
CUgraphNode *to, size_t numDependencies)
Removes dependency edges from a graph.
Detailed Description
\brief graph management functions of the low-level CUDA driver API (cuda.h)
This section describes the graph management functions of the low-level CUDA driver
application programming interface.
Function Documentation
CUresult cuGraphAddChildGraphNode (CUgraphNode * phGraphNode, CUgraph hGraph, const
CUgraphNode * dependencies, size_t numDependencies, CUgraph childGraph)
Creates a new node which executes an embedded graph, and adds it to hGraph with
numDependencies dependencies specified via dependencies. It is possible for
numDependencies to be 0, in which case the node will be placed at the root of the graph.
dependencies may not have any duplicate entries. A handle to the new node will be returned
in phGraphNode.
The node executes an embedded child graph. The child graph is cloned in this call.
Parameters:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
childGraph - The graph to clone into this node
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphChildGraphNodeGetGraph, cuGraphCreate, cuGraphDestroyNode, cuGraphAddEmptyNode,
cuGraphAddKernelNode, cuGraphAddHostNode, cuGraphAddMemcpyNode, cuGraphAddMemsetNode,
cuGraphClone
CUresult cuGraphAddDependencies (CUgraph hGraph, const CUgraphNode * from, const CUgraphNode *
to, size_t numDependencies)
The number of dependencies to be added is defined by numDependencies Elements in from and
to at corresponding indices define a dependency. Each node in from and to must belong to
hGraph.
If numDependencies is 0, elements in from and to will be ignored. Specifying an existing
dependency will return an error.
Parameters:
hGraph - 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:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphRemoveDependencies, cuGraphGetEdges, cuGraphNodeGetDependencies,
cuGraphNodeGetDependentNodes
CUresult cuGraphAddEmptyNode (CUgraphNode * phGraphNode, CUgraph hGraph, const CUgraphNode *
dependencies, size_t numDependencies)
Creates a new node which performs no operation, and adds it to hGraph with numDependencies
dependencies specified via dependencies. It is possible for numDependencies to be 0, in
which case the node will be placed at the root of the graph. dependencies may not have any
duplicate entries. A handle to the new node will be returned in phGraphNode.
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:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate, cuGraphDestroyNode, cuGraphAddChildGraphNode, cuGraphAddKernelNode,
cuGraphAddHostNode, cuGraphAddMemcpyNode, cuGraphAddMemsetNode
CUresult cuGraphAddHostNode (CUgraphNode * phGraphNode, CUgraph hGraph, const CUgraphNode *
dependencies, size_t numDependencies, const CUDA_HOST_NODE_PARAMS * nodeParams)
Creates a new CPU execution node and adds it to hGraph with numDependencies dependencies
specified via dependencies and arguments specified in nodeParams. It is possible for
numDependencies to be 0, in which case the node will be placed at the root of the graph.
dependencies may not have any duplicate entries. A handle to the new node will be returned
in phGraphNode.
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:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
nodeParams - Parameters for the host node
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_NOT_SUPPORTED, CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchHostFunc, cuGraphHostNodeGetParams, cuGraphHostNodeSetParams, cuGraphCreate,
cuGraphDestroyNode, cuGraphAddChildGraphNode, cuGraphAddEmptyNode,
cuGraphAddKernelNode, cuGraphAddMemcpyNode, cuGraphAddMemsetNode
CUresult cuGraphAddKernelNode (CUgraphNode * phGraphNode, CUgraph hGraph, const CUgraphNode *
dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS * nodeParams)
Creates a new kernel execution node and adds it to hGraph with numDependencies
dependencies specified via dependencies and arguments specified in nodeParams. It is
possible for numDependencies to be 0, in which case the node will be placed at the root of
the graph. dependencies may not have any duplicate entries. A handle to the new node will
be returned in phGraphNode.
The CUDA_KERNEL_NODE_PARAMS structure is defined as:
typedef struct CUDA_KERNEL_NODE_PARAMS_st {
CUfunction func;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
void **kernelParams;
void **extra;
} CUDA_KERNEL_NODE_PARAMS;
When the graph is launched, the node will invoke kernel func on a (gridDimX x gridDimY x
gridDimZ) grid of blocks. Each block contains (blockDimX x blockDimY x blockDimZ) threads.
sharedMemBytes 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 CUDA_ERROR_INVALID_VALUE 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:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
nodeParams - Parameters for the GPU execution node
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchKernel, cuGraphKernelNodeGetParams, cuGraphKernelNodeSetParams, cuGraphCreate,
cuGraphDestroyNode, cuGraphAddChildGraphNode, cuGraphAddEmptyNode, cuGraphAddHostNode,
cuGraphAddMemcpyNode, cuGraphAddMemsetNode
CUresult cuGraphAddMemcpyNode (CUgraphNode * phGraphNode, CUgraph hGraph, const CUgraphNode *
dependencies, size_t numDependencies, const CUDA_MEMCPY3D * copyParams, CUcontext ctx)
Creates a new memcpy node and adds it to hGraph with numDependencies dependencies
specified via dependencies. It is possible for numDependencies to be 0, in which case the
node will be placed at the root of the graph. dependencies may not have any duplicate
entries. A handle to the new node will be returned in phGraphNode.
When the graph is launched, the node will perform the memcpy described by copyParams. See
cuMemcpy3D() 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
CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If one or more of the operands refer to
managed memory, then using the memory type CU_MEMORYTYPE_UNIFIED is disallowed for those
operand(s). The managed memory will be treated as residing on either the host or the
device, depending on which memory type is specified.
Parameters:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
copyParams - Parameters for the memory copy
ctx - Context on which to run the node
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemcpy3D, cuGraphMemcpyNodeGetParams, cuGraphMemcpyNodeSetParams, cuGraphCreate,
cuGraphDestroyNode, cuGraphAddChildGraphNode, cuGraphAddEmptyNode,
cuGraphAddKernelNode, cuGraphAddHostNode, cuGraphAddMemsetNode
CUresult cuGraphAddMemsetNode (CUgraphNode * phGraphNode, CUgraph hGraph, const CUgraphNode *
dependencies, size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS * memsetParams,
CUcontext ctx)
Creates a new memset node and adds it to hGraph with numDependencies dependencies
specified via dependencies. It is possible for numDependencies to be 0, in which case the
node will be placed at the root of the graph. dependencies may not have any duplicate
entries. A handle to the new node will be returned in phGraphNode.
The element size must be 1, 2, or 4 bytes. When the graph is launched, the node will
perform the memset described by memsetParams.
Parameters:
phGraphNode - Returns newly created node
hGraph - Graph to which to add the node
dependencies - Dependencies of the node
numDependencies - Number of dependencies
memsetParams - Parameters for the memory set
ctx - Context on which to run the node
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_CONTEXT
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemsetD2D32, cuGraphMemsetNodeGetParams, cuGraphMemsetNodeSetParams, cuGraphCreate,
cuGraphDestroyNode, cuGraphAddChildGraphNode, cuGraphAddEmptyNode,
cuGraphAddKernelNode, cuGraphAddHostNode, cuGraphAddMemcpyNode
CUresult cuGraphChildGraphNodeGetGraph (CUgraphNode hNode, CUgraph * phGraph)
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:
hNode - Node to get the embedded graph for
phGraph - Location to store a handle to the graph
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphAddChildGraphNode, cuGraphNodeFindInClone
CUresult cuGraphClone (CUgraph * phGraphClone, CUgraph originalGraph)
This function creates a copy of originalGraph and returns it in * phGraphClone. 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:
phGraphClone - Returns newly created cloned graph
originalGraph - Graph to clone
Returns:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate, cuGraphNodeFindInClone
CUresult cuGraphCreate (CUgraph * phGraph, unsigned int flags)
Creates an empty graph, which is returned via phGraph.
Parameters:
phGraph - Returns newly created graph
flags - Graph creation flags, must be 0
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphAddChildGraphNode, cuGraphAddEmptyNode, cuGraphAddKernelNode,
cuGraphAddHostNode, cuGraphAddMemcpyNode, cuGraphAddMemsetNode, cuGraphInstantiate,
cuGraphDestroy, cuGraphGetNodes, cuGraphGetRootNodes, cuGraphGetEdges, cuGraphClone
CUresult cuGraphDestroy (CUgraph hGraph)
Destroys the graph specified by hGraph, as well as all of its nodes.
Parameters:
hGraph - Graph to destroy
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate
CUresult cuGraphDestroyNode (CUgraphNode hNode)
Removes hNode from its graph. This operation also severs any dependencies of other nodes
on hNode and vice versa.
Parameters:
hNode - Node to remove
Returns:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphAddChildGraphNode, cuGraphAddEmptyNode, cuGraphAddKernelNode,
cuGraphAddHostNode, cuGraphAddMemcpyNode, cuGraphAddMemsetNode
CUresult cuGraphExecDestroy (CUgraphExec hGraphExec)
Destroys the executable graph specified by hGraphExec, as well as all of its executable
nodes. If the executable graph is in-flight, it will not be terminated, but rather freed
asynchronously on completion.
Parameters:
hGraphExec - Executable graph to destroy
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphInstantiate, cuGraphLaunch
CUresult cuGraphExecKernelNodeSetParams (CUgraphExec hGraphExec, CUgraphNode hNode, const
CUDA_KERNEL_NODE_PARAMS * nodeParams)
Sets the parameters of a kernel node in an executable graph hGraphExec. The node is
identified by the corresponding node hNode in the non-executable graph, from which the
executable graph was instantiated.
hNode 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 take effect at the next launch of hGraphExec. Already enqueued or
running launches of hGraphExec are not affected by this call. hNode is also not modified
by this call.
Parameters:
hGraphExec - The executable graph in which to set the specified node
hNode - kernel node from the graph from which graphExec was instantiated
nodeParams - Updated Parameters to set
Returns:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphAddKernelNode, cuGraphKernelNodeSetParams, cuGraphInstantiate
CUresult cuGraphGetEdges (CUgraph hGraph, CUgraphNode * from, CUgraphNode * to, size_t *
numEdges)
Returns a list of hGraph'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:
hGraph - Graph to get the edges from
from - Location to return edge endpoints
to - Location to return edge endpoints
numEdges - See description
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphGetNodes, cuGraphGetRootNodes, cuGraphAddDependencies,
cuGraphRemoveDependencies, cuGraphNodeGetDependencies, cuGraphNodeGetDependentNodes
CUresult cuGraphGetNodes (CUgraph hGraph, CUgraphNode * nodes, size_t * numNodes)
Returns a list of hGraph'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:
hGraph - Graph to query
nodes - Pointer to return the nodes
numNodes - See description
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate, cuGraphGetRootNodes, cuGraphGetEdges, cuGraphNodeGetType,
cuGraphNodeGetDependencies, cuGraphNodeGetDependentNodes
CUresult cuGraphGetRootNodes (CUgraph hGraph, CUgraphNode * rootNodes, size_t * numRootNodes)
Returns a list of hGraph's root nodes. rootNodes may be NULL, in which case this function
will return the number of root nodes in numRootNodes. Otherwise, numRootNodes entries will
be filled in. If numRootNodes is higher than the actual number of root nodes, the
remaining entries in rootNodes will be set to NULL, and the number of nodes actually
obtained will be returned in numRootNodes.
Parameters:
hGraph - Graph to query
rootNodes - Pointer to return the root nodes
numRootNodes - See description
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate, cuGraphGetNodes, cuGraphGetEdges, cuGraphNodeGetType,
cuGraphNodeGetDependencies, cuGraphNodeGetDependentNodes
CUresult cuGraphHostNodeGetParams (CUgraphNode hNode, CUDA_HOST_NODE_PARAMS * nodeParams)
Returns the parameters of host node hNode in nodeParams.
Parameters:
hNode - Node to get the parameters for
nodeParams - Pointer to return the parameters
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchHostFunc, cuGraphAddHostNode, cuGraphHostNodeSetParams
CUresult cuGraphHostNodeSetParams (CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS *
nodeParams)
Sets the parameters of host node hNode to nodeParams.
Parameters:
hNode - Node to set the parameters for
nodeParams - Parameters to copy
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchHostFunc, cuGraphAddHostNode, cuGraphHostNodeGetParams
CUresult cuGraphInstantiate (CUgraphExec * phGraphExec, CUgraph hGraph, CUgraphNode *
phErrorNode, char * logBuffer, size_t bufferSize)
Instantiates hGraph 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 graphExec.
If there are any errors, diagnostic information may be returned in errorNode and
logBuffer. 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:
phGraphExec - Returns instantiated graph
hGraph - Graph to instantiate
phErrorNode - In case of an instantiation error, this may be modified to indicate a
node contributing to the error
logBuffer - A character buffer to store diagnostic messages
bufferSize - Size of the log buffer in bytes
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphCreate, cuGraphLaunch, cuGraphExecDestroy
CUresult cuGraphKernelNodeGetParams (CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS * nodeParams)
Returns the parameters of kernel node hNode in nodeParams. The kernelParams or extra array
returned in nodeParams, 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 cuGraphKernelNodeSetParams 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:
hNode - Node to get the parameters for
nodeParams - Pointer to return the parameters
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchKernel, cuGraphAddKernelNode, cuGraphKernelNodeSetParams
CUresult cuGraphKernelNodeSetParams (CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS *
nodeParams)
Sets the parameters of kernel node hNode to nodeParams.
Parameters:
hNode - Node to set the parameters for
nodeParams - Parameters to copy
Returns:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE,
CUDA_ERROR_OUT_OF_MEMORY
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuLaunchKernel, cuGraphAddKernelNode, cuGraphKernelNodeGetParams
CUresult cuGraphLaunch (CUgraphExec hGraphExec, CUstream hStream)
Executes hGraphExec in hStream. Only one instance of hGraphExec may be executing at a
time. Each launch is ordered behind both any previous work in hStream and any previous
launches of hGraphExec. To execute a graph concurrently, it must be instantiated multiple
times into multiple executable graphs.
Parameters:
hGraphExec - Executable graph to launch
hStream - Stream in which to launch the graph
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphInstantiate, cuGraphExecDestroy
CUresult cuGraphMemcpyNodeGetParams (CUgraphNode hNode, CUDA_MEMCPY3D * nodeParams)
Returns the parameters of memcpy node hNode in nodeParams.
Parameters:
hNode - Node to get the parameters for
nodeParams - Pointer to return the parameters
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemcpy3D, cuGraphAddMemcpyNode, cuGraphMemcpyNodeSetParams
CUresult cuGraphMemcpyNodeSetParams (CUgraphNode hNode, const CUDA_MEMCPY3D * nodeParams)
Sets the parameters of memcpy node hNode to nodeParams.
Parameters:
hNode - Node to set the parameters for
nodeParams - Parameters to copy
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemcpy3D, cuGraphAddMemcpyNode, cuGraphMemcpyNodeGetParams
CUresult cuGraphMemsetNodeGetParams (CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS * nodeParams)
Returns the parameters of memset node hNode in nodeParams.
Parameters:
hNode - Node to get the parameters for
nodeParams - Pointer to return the parameters
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemsetD2D32, cuGraphAddMemsetNode, cuGraphMemsetNodeSetParams
CUresult cuGraphMemsetNodeSetParams (CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS *
nodeParams)
Sets the parameters of memset node hNode to nodeParams.
Parameters:
hNode - Node to set the parameters for
nodeParams - Parameters to copy
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuMemsetD2D32, cuGraphAddMemsetNode, cuGraphMemsetNodeGetParams
CUresult cuGraphNodeFindInClone (CUgraphNode * phNode, CUgraphNode hOriginalNode, CUgraph
hClonedGraph)
This function returns the node in hClonedGraph corresponding to hOriginalNode in the
original graph.
hClonedGraph must have been cloned from hOriginalGraph via cuGraphClone. hOriginalNode
must have been in hOriginalGraph at the time of the call to cuGraphClone, and the
corresponding cloned node in hClonedGraph must not have been removed. The cloned node is
then returned via phClonedNode.
Parameters:
phNode - Returns handle to the cloned node
hOriginalNode - Handle to the original node
hClonedGraph - Cloned graph to query
Returns:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE,
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphClone
CUresult cuGraphNodeGetDependencies (CUgraphNode hNode, CUgraphNode * dependencies, size_t *
numDependencies)
Returns a list of node's dependencies. dependencies may be NULL, in which case this
function will return the number of dependencies in numDependencies. Otherwise,
numDependencies entries will be filled in. If numDependencies is higher than the actual
number of dependencies, the remaining entries in dependencies will be set to NULL, and the
number of nodes actually obtained will be returned in numDependencies.
Parameters:
hNode - Node to query
dependencies - Pointer to return the dependencies
numDependencies - See description
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphNodeGetDependentNodes, cuGraphGetNodes, cuGraphGetRootNodes, cuGraphGetEdges,
cuGraphAddDependencies, cuGraphRemoveDependencies
CUresult cuGraphNodeGetDependentNodes (CUgraphNode hNode, CUgraphNode * dependentNodes, size_t
* numDependentNodes)
Returns a list of node's dependent nodes. dependentNodes may be NULL, in which case this
function will return the number of dependent nodes in numDependentNodes. Otherwise,
numDependentNodes entries will be filled in. If numDependentNodes is higher than the
actual number of dependent nodes, the remaining entries in dependentNodes will be set to
NULL, and the number of nodes actually obtained will be returned in numDependentNodes.
Parameters:
hNode - Node to query
dependentNodes - Pointer to return the dependent nodes
numDependentNodes - See description
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphNodeGetDependencies, cuGraphGetNodes, cuGraphGetRootNodes, cuGraphGetEdges,
cuGraphAddDependencies, cuGraphRemoveDependencies
CUresult cuGraphNodeGetType (CUgraphNode hNode, CUgraphNodeType * type)
Returns the node type of hNode in type.
Parameters:
hNode - Node to query
type - Pointer to return the node type
Returns:
CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphGetNodes, cuGraphGetRootNodes, cuGraphChildGraphNodeGetGraph,
cuGraphKernelNodeGetParams, cuGraphKernelNodeSetParams, cuGraphHostNodeGetParams,
cuGraphHostNodeSetParams, cuGraphMemcpyNodeGetParams, cuGraphMemcpyNodeSetParams,
cuGraphMemsetNodeGetParams, cuGraphMemsetNodeSetParams
CUresult cuGraphRemoveDependencies (CUgraph hGraph, const CUgraphNode * from, const
CUgraphNode * to, size_t numDependencies)
The number of dependencies to be removed is defined by numDependencies. Elements in from
and to at corresponding indices define a dependency. Each node in from and to must belong
to hGraph.
If numDependencies is 0, elements in from and to will be ignored. Specifying a non-
existing dependency will return an error.
Parameters:
hGraph - 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:
CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE
Note:
Graph objects are not threadsafe. .
Note that this function may also return error codes from previous, asynchronous
launches.
See also:
cuGraphAddDependencies, cuGraphGetEdges, cuGraphNodeGetDependencies,
cuGraphNodeGetDependentNodes
Author
Generated automatically by Doxygen from the source code.