.TH "Graph Management" 3 "24 Apr 2019" "Version 6.0" "Doxygen" \" -*- nroff -*-
.ad l
.nh
.SH NAME
Graph Management \- 
.SS "Functions"

.in +1c
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddChildGraphNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies, \fBCUgraph\fP childGraph)"
.br
.RI "\fICreates a child graph node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddDependencies\fP (\fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *from, const \fBCUgraphNode\fP *to, size_t numDependencies)"
.br
.RI "\fIAdds dependency edges to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddEmptyNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies)"
.br
.RI "\fICreates an empty node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddHostNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies, const \fBCUDA_HOST_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fICreates a host execution node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddKernelNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies, const \fBCUDA_KERNEL_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fICreates a kernel execution node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddMemcpyNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies, const \fBCUDA_MEMCPY3D\fP *copyParams, \fBCUcontext\fP ctx)"
.br
.RI "\fICreates a memcpy node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphAddMemsetNode\fP (\fBCUgraphNode\fP *phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *dependencies, size_t numDependencies, const \fBCUDA_MEMSET_NODE_PARAMS\fP *memsetParams, \fBCUcontext\fP ctx)"
.br
.RI "\fICreates a memset node and adds it to a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphChildGraphNodeGetGraph\fP (\fBCUgraphNode\fP hNode, \fBCUgraph\fP *phGraph)"
.br
.RI "\fIGets a handle to the embedded graph of a child graph node. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphClone\fP (\fBCUgraph\fP *phGraphClone, \fBCUgraph\fP originalGraph)"
.br
.RI "\fIClones a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphCreate\fP (\fBCUgraph\fP *phGraph, unsigned int flags)"
.br
.RI "\fICreates a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphDestroy\fP (\fBCUgraph\fP hGraph)"
.br
.RI "\fIDestroys a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphDestroyNode\fP (\fBCUgraphNode\fP hNode)"
.br
.RI "\fIRemove a node from the graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphExecDestroy\fP (\fBCUgraphExec\fP hGraphExec)"
.br
.RI "\fIDestroys an executable graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphExecKernelNodeSetParams\fP (\fBCUgraphExec\fP hGraphExec, \fBCUgraphNode\fP hNode, const \fBCUDA_KERNEL_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fISets the parameters for a kernel node in the given graphExec. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphGetEdges\fP (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP *from, \fBCUgraphNode\fP *to, size_t *numEdges)"
.br
.RI "\fIReturns a graph's dependency edges. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphGetNodes\fP (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP *nodes, size_t *numNodes)"
.br
.RI "\fIReturns a graph's nodes. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphGetRootNodes\fP (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP *rootNodes, size_t *numRootNodes)"
.br
.RI "\fIReturns a graph's root nodes. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphHostNodeGetParams\fP (\fBCUgraphNode\fP hNode, \fBCUDA_HOST_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fIReturns a host node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphHostNodeSetParams\fP (\fBCUgraphNode\fP hNode, const \fBCUDA_HOST_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fISets a host node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphInstantiate\fP (\fBCUgraphExec\fP *phGraphExec, \fBCUgraph\fP hGraph, \fBCUgraphNode\fP *phErrorNode, char *logBuffer, size_t bufferSize)"
.br
.RI "\fICreates an executable graph from a graph. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphKernelNodeGetParams\fP (\fBCUgraphNode\fP hNode, \fBCUDA_KERNEL_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fIReturns a kernel node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphKernelNodeSetParams\fP (\fBCUgraphNode\fP hNode, const \fBCUDA_KERNEL_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fISets a kernel node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphLaunch\fP (\fBCUgraphExec\fP hGraphExec, \fBCUstream\fP hStream)"
.br
.RI "\fILaunches an executable graph in a stream. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphMemcpyNodeGetParams\fP (\fBCUgraphNode\fP hNode, \fBCUDA_MEMCPY3D\fP *nodeParams)"
.br
.RI "\fIReturns a memcpy node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphMemcpyNodeSetParams\fP (\fBCUgraphNode\fP hNode, const \fBCUDA_MEMCPY3D\fP *nodeParams)"
.br
.RI "\fISets a memcpy node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphMemsetNodeGetParams\fP (\fBCUgraphNode\fP hNode, \fBCUDA_MEMSET_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fIReturns a memset node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphMemsetNodeSetParams\fP (\fBCUgraphNode\fP hNode, const \fBCUDA_MEMSET_NODE_PARAMS\fP *nodeParams)"
.br
.RI "\fISets a memset node's parameters. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphNodeFindInClone\fP (\fBCUgraphNode\fP *phNode, \fBCUgraphNode\fP hOriginalNode, \fBCUgraph\fP hClonedGraph)"
.br
.RI "\fIFinds a cloned version of a node. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphNodeGetDependencies\fP (\fBCUgraphNode\fP hNode, \fBCUgraphNode\fP *dependencies, size_t *numDependencies)"
.br
.RI "\fIReturns a node's dependencies. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphNodeGetDependentNodes\fP (\fBCUgraphNode\fP hNode, \fBCUgraphNode\fP *dependentNodes, size_t *numDependentNodes)"
.br
.RI "\fIReturns a node's dependent nodes. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphNodeGetType\fP (\fBCUgraphNode\fP hNode, \fBCUgraphNodeType\fP *type)"
.br
.RI "\fIReturns a node's type. \fP"
.ti -1c
.RI "\fBCUresult\fP \fBcuGraphRemoveDependencies\fP (\fBCUgraph\fP hGraph, const \fBCUgraphNode\fP *from, const \fBCUgraphNode\fP *to, size_t numDependencies)"
.br
.RI "\fIRemoves dependency edges from a graph. \fP"
.in -1c
.SH "Detailed Description"
.PP 
\\brief graph management functions of the low-level CUDA driver API (\fBcuda.h\fP)
.PP
This section describes the graph management functions of the low-level CUDA driver application programming interface. 
.SH "Function Documentation"
.PP 
.SS "\fBCUresult\fP cuGraphAddChildGraphNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies, \fBCUgraph\fP childGraph)"
.PP
Creates a new node which executes an embedded graph, and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
The node executes an embedded child graph. The child graph is cloned in this call.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies 
.br
\fIchildGraph\fP - The graph to clone into this node
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphChildGraphNodeGetGraph\fP, \fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP, \fBcuGraphClone\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddDependencies (\fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * from, const \fBCUgraphNode\fP * to, size_t numDependencies)"
.PP
The number of dependencies to be added is defined by \fCnumDependencies\fP Elements in \fCfrom\fP and \fCto\fP at corresponding indices define a dependency. Each node in \fCfrom\fP and \fCto\fP must belong to \fChGraph\fP.
.PP
If \fCnumDependencies\fP is 0, elements in \fCfrom\fP and \fCto\fP will be ignored. Specifying an existing dependency will return an error.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph to which dependencies are added 
.br
\fIfrom\fP - Array of nodes that provide the dependencies 
.br
\fIto\fP - Array of dependent nodes 
.br
\fInumDependencies\fP - Number of dependencies to be added
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphRemoveDependencies\fP, \fBcuGraphGetEdges\fP, \fBcuGraphNodeGetDependencies\fP, \fBcuGraphNodeGetDependentNodes\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddEmptyNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies)"
.PP
Creates a new node which performs no operation, and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
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.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddHostNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies, const \fBCUDA_HOST_NODE_PARAMS\fP * nodeParams)"
.PP
Creates a new CPU execution node and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP and arguments specified in \fCnodeParams\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
When the graph is launched, the node will invoke the specified CPU function. Host nodes are not supported under MPS with pre-Volta GPUs.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies 
.br
\fInodeParams\fP - Parameters for the host node
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_NOT_SUPPORTED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchHostFunc\fP, \fBcuGraphHostNodeGetParams\fP, \fBcuGraphHostNodeSetParams\fP, \fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddKernelNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies, const \fBCUDA_KERNEL_NODE_PARAMS\fP * nodeParams)"
.PP
Creates a new kernel execution node and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP and arguments specified in \fCnodeParams\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
The \fBCUDA_KERNEL_NODE_PARAMS\fP structure is defined as:
.PP
.PP
.nf
  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;
.fi
.PP
.PP
When the graph is launched, the node will invoke kernel \fCfunc\fP on a (\fCgridDimX\fP x \fCgridDimY\fP x \fCgridDimZ\fP) grid of blocks. Each block contains (\fCblockDimX\fP x \fCblockDimY\fP x \fCblockDimZ\fP) threads.
.PP
\fCsharedMemBytes\fP sets the amount of dynamic shared memory that will be available to each thread block.
.PP
Kernel parameters to \fCfunc\fP can be specified in one of two ways:
.PP
1) Kernel parameters can be specified via \fCkernelParams\fP. If the kernel has N parameters, then \fCkernelParams\fP needs to be an array of N pointers. Each pointer, from \fCkernelParams\fP[0] to \fCkernelParams\fP[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.
.PP
2) Kernel parameters can also be packaged by the application into a single buffer that is passed in via \fCextra\fP. This places the burden on the application of knowing each kernel parameter's size and alignment/padding within the buffer. The \fCextra\fP parameter exists to allow this function to take additional less commonly used arguments. \fCextra\fP 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.
.PP
.IP "\(bu" 2
\fBCU_LAUNCH_PARAM_END\fP, which indicates the end of the \fCextra\fP array;
.IP "\(bu" 2
\fBCU_LAUNCH_PARAM_BUFFER_POINTER\fP, which specifies that the next value in \fCextra\fP will be a pointer to a buffer containing all the kernel parameters for launching kernel \fCfunc\fP;
.IP "\(bu" 2
\fBCU_LAUNCH_PARAM_BUFFER_SIZE\fP, which specifies that the next value in \fCextra\fP will be a pointer to a size_t containing the size of the buffer specified with \fBCU_LAUNCH_PARAM_BUFFER_POINTER\fP;
.PP
.PP
The error \fBCUDA_ERROR_INVALID_VALUE\fP will be returned if kernel parameters are specified with both \fCkernelParams\fP and \fCextra\fP (i.e. both \fCkernelParams\fP and \fCextra\fP are non-NULL).
.PP
The \fCkernelParams\fP or \fCextra\fP array, as well as the argument values it points to, are copied during this call.
.PP
\fBNote:\fP
.RS 4
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.
.RE
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies 
.br
\fInodeParams\fP - Parameters for the GPU execution node
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchKernel\fP, \fBcuGraphKernelNodeGetParams\fP, \fBcuGraphKernelNodeSetParams\fP, \fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddMemcpyNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies, const \fBCUDA_MEMCPY3D\fP * copyParams, \fBCUcontext\fP ctx)"
.PP
Creates a new memcpy node and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
When the graph is launched, the node will perform the memcpy described by \fCcopyParams\fP. See \fBcuMemcpy3D()\fP for a description of the structure and its restrictions.
.PP
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 \fBCU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS\fP. If one or more of the operands refer to managed memory, then using the memory type \fBCU_MEMORYTYPE_UNIFIED\fP 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.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies 
.br
\fIcopyParams\fP - Parameters for the memory copy 
.br
\fIctx\fP - Context on which to run the node
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemcpy3D\fP, \fBcuGraphMemcpyNodeGetParams\fP, \fBcuGraphMemcpyNodeSetParams\fP, \fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemsetNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphAddMemsetNode (\fBCUgraphNode\fP * phGraphNode, \fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * dependencies, size_t numDependencies, const \fBCUDA_MEMSET_NODE_PARAMS\fP * memsetParams, \fBCUcontext\fP ctx)"
.PP
Creates a new memset node and adds it to \fChGraph\fP with \fCnumDependencies\fP dependencies specified via \fCdependencies\fP. It is possible for \fCnumDependencies\fP to be 0, in which case the node will be placed at the root of the graph. \fCdependencies\fP may not have any duplicate entries. A handle to the new node will be returned in \fCphGraphNode\fP.
.PP
The element size must be 1, 2, or 4 bytes. When the graph is launched, the node will perform the memset described by \fCmemsetParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphNode\fP - Returns newly created node 
.br
\fIhGraph\fP - Graph to which to add the node 
.br
\fIdependencies\fP - Dependencies of the node 
.br
\fInumDependencies\fP - Number of dependencies 
.br
\fImemsetParams\fP - Parameters for the memory set 
.br
\fIctx\fP - Context on which to run the node
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, \fBCUDA_ERROR_INVALID_CONTEXT\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemsetD2D32\fP, \fBcuGraphMemsetNodeGetParams\fP, \fBcuGraphMemsetNodeSetParams\fP, \fBcuGraphCreate\fP, \fBcuGraphDestroyNode\fP, \fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphChildGraphNodeGetGraph (\fBCUgraphNode\fP hNode, \fBCUgraph\fP * phGraph)"
.PP
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.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to get the embedded graph for 
.br
\fIphGraph\fP - Location to store a handle to the graph
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphAddChildGraphNode\fP, \fBcuGraphNodeFindInClone\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphClone (\fBCUgraph\fP * phGraphClone, \fBCUgraph\fP originalGraph)"
.PP
This function creates a copy of \fCoriginalGraph\fP and returns it in \fC*\fP phGraphClone. All parameters are copied into the cloned graph. The original graph may be modified after this call without affecting the clone.
.PP
Child graph nodes in the original graph are recursively copied into the clone.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphClone\fP - Returns newly created cloned graph 
.br
\fIoriginalGraph\fP - Graph to clone
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, \fBCUDA_ERROR_OUT_OF_MEMORY\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP, \fBcuGraphNodeFindInClone\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphCreate (\fBCUgraph\fP * phGraph, unsigned int flags)"
.PP
Creates an empty graph, which is returned via \fCphGraph\fP.
.PP
\fBParameters:\fP
.RS 4
\fIphGraph\fP - Returns newly created graph 
.br
\fIflags\fP - Graph creation flags, must be 0
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, \fBCUDA_ERROR_OUT_OF_MEMORY\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP, \fBcuGraphInstantiate\fP, \fBcuGraphDestroy\fP, \fBcuGraphGetNodes\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphGetEdges\fP, \fBcuGraphClone\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphDestroy (\fBCUgraph\fP hGraph)"
.PP
Destroys the graph specified by \fChGraph\fP, as well as all of its nodes.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph to destroy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphDestroyNode (\fBCUgraphNode\fP hNode)"
.PP
Removes \fChNode\fP from its graph. This operation also severs any dependencies of other nodes on \fChNode\fP and vice versa.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to remove
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphAddChildGraphNode\fP, \fBcuGraphAddEmptyNode\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphAddMemsetNode\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphExecDestroy (\fBCUgraphExec\fP hGraphExec)"
.PP
Destroys the executable graph specified by \fChGraphExec\fP, 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.
.PP
\fBParameters:\fP
.RS 4
\fIhGraphExec\fP - Executable graph to destroy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphInstantiate\fP, \fBcuGraphLaunch\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphExecKernelNodeSetParams (\fBCUgraphExec\fP hGraphExec, \fBCUgraphNode\fP hNode, const \fBCUDA_KERNEL_NODE_PARAMS\fP * nodeParams)"
.PP
Sets the parameters of a kernel node in an executable graph \fChGraphExec\fP. The node is identified by the corresponding node \fChNode\fP in the non-executable graph, from which the executable graph was instantiated.
.PP
\fChNode\fP must not have been removed from the original graph. The \fCfunc\fP field of \fCnodeParams\fP cannot be modified and must match the original value. All other values can be modified.
.PP
The modifications take effect at the next launch of \fChGraphExec\fP. Already enqueued or running launches of \fChGraphExec\fP are not affected by this call. \fChNode\fP is also not modified by this call.
.PP
\fBParameters:\fP
.RS 4
\fIhGraphExec\fP - The executable graph in which to set the specified node 
.br
\fIhNode\fP - kernel node from the graph from which graphExec was instantiated 
.br
\fInodeParams\fP - Updated Parameters to set
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphAddKernelNode\fP, \fBcuGraphKernelNodeSetParams\fP, \fBcuGraphInstantiate\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphGetEdges (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP * from, \fBCUgraphNode\fP * to, size_t * numEdges)"
.PP
Returns a list of \fChGraph's\fP dependency edges. Edges are returned via corresponding indices in \fCfrom\fP and \fCto\fP; that is, the node in \fCto\fP[i] has a dependency on the node in \fCfrom\fP[i]. \fCfrom\fP and \fCto\fP may both be NULL, in which case this function only returns the number of edges in \fCnumEdges\fP. Otherwise, \fCnumEdges\fP entries will be filled in. If \fCnumEdges\fP is higher than the actual number of edges, the remaining entries in \fCfrom\fP and \fCto\fP will be set to NULL, and the number of edges actually returned will be written to \fCnumEdges\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph to get the edges from 
.br
\fIfrom\fP - Location to return edge endpoints 
.br
\fIto\fP - Location to return edge endpoints 
.br
\fInumEdges\fP - See description
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphGetNodes\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphAddDependencies\fP, \fBcuGraphRemoveDependencies\fP, \fBcuGraphNodeGetDependencies\fP, \fBcuGraphNodeGetDependentNodes\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphGetNodes (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP * nodes, size_t * numNodes)"
.PP
Returns a list of \fChGraph's\fP nodes. \fCnodes\fP may be NULL, in which case this function will return the number of nodes in \fCnumNodes\fP. Otherwise, \fCnumNodes\fP entries will be filled in. If \fCnumNodes\fP is higher than the actual number of nodes, the remaining entries in \fCnodes\fP will be set to NULL, and the number of nodes actually obtained will be returned in \fCnumNodes\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph to query 
.br
\fInodes\fP - Pointer to return the nodes 
.br
\fInumNodes\fP - See description
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphGetEdges\fP, \fBcuGraphNodeGetType\fP, \fBcuGraphNodeGetDependencies\fP, \fBcuGraphNodeGetDependentNodes\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphGetRootNodes (\fBCUgraph\fP hGraph, \fBCUgraphNode\fP * rootNodes, size_t * numRootNodes)"
.PP
Returns a list of \fChGraph's\fP root nodes. \fCrootNodes\fP may be NULL, in which case this function will return the number of root nodes in \fCnumRootNodes\fP. Otherwise, \fCnumRootNodes\fP entries will be filled in. If \fCnumRootNodes\fP is higher than the actual number of root nodes, the remaining entries in \fCrootNodes\fP will be set to NULL, and the number of nodes actually obtained will be returned in \fCnumRootNodes\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph to query 
.br
\fIrootNodes\fP - Pointer to return the root nodes 
.br
\fInumRootNodes\fP - See description
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP, \fBcuGraphGetNodes\fP, \fBcuGraphGetEdges\fP, \fBcuGraphNodeGetType\fP, \fBcuGraphNodeGetDependencies\fP, \fBcuGraphNodeGetDependentNodes\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphHostNodeGetParams (\fBCUgraphNode\fP hNode, \fBCUDA_HOST_NODE_PARAMS\fP * nodeParams)"
.PP
Returns the parameters of host node \fChNode\fP in \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to get the parameters for 
.br
\fInodeParams\fP - Pointer to return the parameters
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchHostFunc\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphHostNodeSetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphHostNodeSetParams (\fBCUgraphNode\fP hNode, const \fBCUDA_HOST_NODE_PARAMS\fP * nodeParams)"
.PP
Sets the parameters of host node \fChNode\fP to \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to set the parameters for 
.br
\fInodeParams\fP - Parameters to copy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchHostFunc\fP, \fBcuGraphAddHostNode\fP, \fBcuGraphHostNodeGetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphInstantiate (\fBCUgraphExec\fP * phGraphExec, \fBCUgraph\fP hGraph, \fBCUgraphNode\fP * phErrorNode, char * logBuffer, size_t bufferSize)"
.PP
Instantiates \fChGraph\fP 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 \fCgraphExec\fP.
.PP
If there are any errors, diagnostic information may be returned in \fCerrorNode\fP and \fClogBuffer\fP. 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.
.PP
\fBParameters:\fP
.RS 4
\fIphGraphExec\fP - Returns instantiated graph 
.br
\fIhGraph\fP - Graph to instantiate 
.br
\fIphErrorNode\fP - In case of an instantiation error, this may be modified to indicate a node contributing to the error 
.br
\fIlogBuffer\fP - A character buffer to store diagnostic messages 
.br
\fIbufferSize\fP - Size of the log buffer in bytes
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphCreate\fP, \fBcuGraphLaunch\fP, \fBcuGraphExecDestroy\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphKernelNodeGetParams (\fBCUgraphNode\fP hNode, \fBCUDA_KERNEL_NODE_PARAMS\fP * nodeParams)"
.PP
Returns the parameters of kernel node \fChNode\fP in \fCnodeParams\fP. The \fCkernelParams\fP or \fCextra\fP array returned in \fCnodeParams\fP, 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 \fBcuGraphKernelNodeSetParams\fP to update the parameters of this node.
.PP
The params will contain either \fCkernelParams\fP or \fCextra\fP, according to which of these was most recently set on the node.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to get the parameters for 
.br
\fInodeParams\fP - Pointer to return the parameters
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchKernel\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphKernelNodeSetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphKernelNodeSetParams (\fBCUgraphNode\fP hNode, const \fBCUDA_KERNEL_NODE_PARAMS\fP * nodeParams)"
.PP
Sets the parameters of kernel node \fChNode\fP to \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to set the parameters for 
.br
\fInodeParams\fP - Parameters to copy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, \fBCUDA_ERROR_INVALID_HANDLE\fP, \fBCUDA_ERROR_OUT_OF_MEMORY\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuLaunchKernel\fP, \fBcuGraphAddKernelNode\fP, \fBcuGraphKernelNodeGetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphLaunch (\fBCUgraphExec\fP hGraphExec, \fBCUstream\fP hStream)"
.PP
Executes \fChGraphExec\fP in \fChStream\fP. Only one instance of \fChGraphExec\fP may be executing at a time. Each launch is ordered behind both any previous work in \fChStream\fP and any previous launches of \fChGraphExec\fP. To execute a graph concurrently, it must be instantiated multiple times into multiple executable graphs.
.PP
\fBParameters:\fP
.RS 4
\fIhGraphExec\fP - Executable graph to launch 
.br
\fIhStream\fP - Stream in which to launch the graph
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphInstantiate\fP, \fBcuGraphExecDestroy\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphMemcpyNodeGetParams (\fBCUgraphNode\fP hNode, \fBCUDA_MEMCPY3D\fP * nodeParams)"
.PP
Returns the parameters of memcpy node \fChNode\fP in \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to get the parameters for 
.br
\fInodeParams\fP - Pointer to return the parameters
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemcpy3D\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphMemcpyNodeSetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphMemcpyNodeSetParams (\fBCUgraphNode\fP hNode, const \fBCUDA_MEMCPY3D\fP * nodeParams)"
.PP
Sets the parameters of memcpy node \fChNode\fP to \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to set the parameters for 
.br
\fInodeParams\fP - Parameters to copy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemcpy3D\fP, \fBcuGraphAddMemcpyNode\fP, \fBcuGraphMemcpyNodeGetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphMemsetNodeGetParams (\fBCUgraphNode\fP hNode, \fBCUDA_MEMSET_NODE_PARAMS\fP * nodeParams)"
.PP
Returns the parameters of memset node \fChNode\fP in \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to get the parameters for 
.br
\fInodeParams\fP - Pointer to return the parameters
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemsetD2D32\fP, \fBcuGraphAddMemsetNode\fP, \fBcuGraphMemsetNodeSetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphMemsetNodeSetParams (\fBCUgraphNode\fP hNode, const \fBCUDA_MEMSET_NODE_PARAMS\fP * nodeParams)"
.PP
Sets the parameters of memset node \fChNode\fP to \fCnodeParams\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to set the parameters for 
.br
\fInodeParams\fP - Parameters to copy
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuMemsetD2D32\fP, \fBcuGraphAddMemsetNode\fP, \fBcuGraphMemsetNodeGetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphNodeFindInClone (\fBCUgraphNode\fP * phNode, \fBCUgraphNode\fP hOriginalNode, \fBCUgraph\fP hClonedGraph)"
.PP
This function returns the node in \fChClonedGraph\fP corresponding to \fChOriginalNode\fP in the original graph.
.PP
\fChClonedGraph\fP must have been cloned from \fChOriginalGraph\fP via \fBcuGraphClone\fP. \fChOriginalNode\fP must have been in \fChOriginalGraph\fP at the time of the call to \fBcuGraphClone\fP, and the corresponding cloned node in \fChClonedGraph\fP must not have been removed. The cloned node is then returned via \fCphClonedNode\fP.
.PP
\fBParameters:\fP
.RS 4
\fIphNode\fP - Returns handle to the cloned node 
.br
\fIhOriginalNode\fP - Handle to the original node 
.br
\fIhClonedGraph\fP - Cloned graph to query
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP, 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphClone\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphNodeGetDependencies (\fBCUgraphNode\fP hNode, \fBCUgraphNode\fP * dependencies, size_t * numDependencies)"
.PP
Returns a list of \fCnode's\fP dependencies. \fCdependencies\fP may be NULL, in which case this function will return the number of dependencies in \fCnumDependencies\fP. Otherwise, \fCnumDependencies\fP entries will be filled in. If \fCnumDependencies\fP is higher than the actual number of dependencies, the remaining entries in \fCdependencies\fP will be set to NULL, and the number of nodes actually obtained will be returned in \fCnumDependencies\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to query 
.br
\fIdependencies\fP - Pointer to return the dependencies 
.br
\fInumDependencies\fP - See description
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphNodeGetDependentNodes\fP, \fBcuGraphGetNodes\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphGetEdges\fP, \fBcuGraphAddDependencies\fP, \fBcuGraphRemoveDependencies\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphNodeGetDependentNodes (\fBCUgraphNode\fP hNode, \fBCUgraphNode\fP * dependentNodes, size_t * numDependentNodes)"
.PP
Returns a list of \fCnode's\fP dependent nodes. \fCdependentNodes\fP may be NULL, in which case this function will return the number of dependent nodes in \fCnumDependentNodes\fP. Otherwise, \fCnumDependentNodes\fP entries will be filled in. If \fCnumDependentNodes\fP is higher than the actual number of dependent nodes, the remaining entries in \fCdependentNodes\fP will be set to NULL, and the number of nodes actually obtained will be returned in \fCnumDependentNodes\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to query 
.br
\fIdependentNodes\fP - Pointer to return the dependent nodes 
.br
\fInumDependentNodes\fP - See description
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphNodeGetDependencies\fP, \fBcuGraphGetNodes\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphGetEdges\fP, \fBcuGraphAddDependencies\fP, \fBcuGraphRemoveDependencies\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphNodeGetType (\fBCUgraphNode\fP hNode, \fBCUgraphNodeType\fP * type)"
.PP
Returns the node type of \fChNode\fP in \fCtype\fP.
.PP
\fBParameters:\fP
.RS 4
\fIhNode\fP - Node to query 
.br
\fItype\fP - Pointer to return the node type
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_DEINITIALIZED\fP, \fBCUDA_ERROR_NOT_INITIALIZED\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphGetNodes\fP, \fBcuGraphGetRootNodes\fP, \fBcuGraphChildGraphNodeGetGraph\fP, \fBcuGraphKernelNodeGetParams\fP, \fBcuGraphKernelNodeSetParams\fP, \fBcuGraphHostNodeGetParams\fP, \fBcuGraphHostNodeSetParams\fP, \fBcuGraphMemcpyNodeGetParams\fP, \fBcuGraphMemcpyNodeSetParams\fP, \fBcuGraphMemsetNodeGetParams\fP, \fBcuGraphMemsetNodeSetParams\fP 
.RE
.PP

.SS "\fBCUresult\fP cuGraphRemoveDependencies (\fBCUgraph\fP hGraph, const \fBCUgraphNode\fP * from, const \fBCUgraphNode\fP * to, size_t numDependencies)"
.PP
The number of \fCdependencies\fP to be removed is defined by \fCnumDependencies\fP. Elements in \fCfrom\fP and \fCto\fP at corresponding indices define a dependency. Each node in \fCfrom\fP and \fCto\fP must belong to \fChGraph\fP.
.PP
If \fCnumDependencies\fP is 0, elements in \fCfrom\fP and \fCto\fP will be ignored. Specifying a non-existing dependency will return an error.
.PP
\fBParameters:\fP
.RS 4
\fIhGraph\fP - Graph from which to remove dependencies 
.br
\fIfrom\fP - Array of nodes that provide the dependencies 
.br
\fIto\fP - Array of dependent nodes 
.br
\fInumDependencies\fP - Number of dependencies to be removed
.RE
.PP
\fBReturns:\fP
.RS 4
\fBCUDA_SUCCESS\fP, \fBCUDA_ERROR_INVALID_VALUE\fP 
.RE
.PP
\fBNote:\fP
.RS 4
Graph objects are not threadsafe. . 
.PP
Note that this function may also return error codes from previous, asynchronous launches.
.RE
.PP
\fBSee also:\fP
.RS 4
\fBcuGraphAddDependencies\fP, \fBcuGraphGetEdges\fP, \fBcuGraphNodeGetDependencies\fP, \fBcuGraphNodeGetDependentNodes\fP 
.RE
.PP

.SH "Author"
.PP 
Generated automatically by Doxygen from the source code.