Coverage for cuda/core/graph/_subclasses.pyx: 88.89%

1# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. (empty)

2# 

3# SPDX-License-Identifier: Apache-2.0 

4  

5"""GraphNode subclasses — EmptyNode through SwitchNode.""" 

6  

7from __future__ import annotations 

8  

9from libc.stddef cimport size_t 

10from libc.stdint cimport uintptr_t 

11from libc.string cimport memset as c_memset 

12  

13from cuda.bindings cimport cydriver 

14  

15from cuda.core._event cimport Event, Event_check_open 

16from cuda.core._kernel_arg_handler cimport ParamHolder 

17from cuda.core._launch_config cimport LaunchConfig 

18from cuda.core._memory._buffer cimport Buffer 

19from cuda.core._module cimport Kernel 

20from cuda.core.graph._graph_definition cimport ( 

21 GraphCondition, 

22 GraphDefinition, 

23 GD_check_valid, 

24) 

25from cuda.core.graph._graph_node cimport ( 

26 GraphNode, 

27 GN_check_valid, 

28 _get_memcpy_memory_type, 

29 _init_memcpy_params, 

30 _resolve_memcpy_operand, 

31) 

32from cuda.core._resource_handles cimport ( 

33 EventHandle, 

34 GraphExecHandle, 

35 GraphHandle, 

36 GraphNodeHandle, 

37 KernelHandle, 

38 OpaqueHandle, 

39 PreparedAttachment, 

40 PreparedChildGraphUpdate, 

41 PreparedExecAttachment, 

42 as_cu, 

43 as_intptr, 

44 create_child_graph_handle, 

45 create_event_handle_ref, 

46 create_kernel_handle_ref, 

47 graph_commit_attachment, 

48 graph_commit_child_graph_update, 

49 graph_commit_exec_attachment, 

50 graph_get_attachment, 

51 graph_node_get_graph, 

52 graph_prepare_attachment, 

53 graph_prepare_child_graph_update, 

54 graph_prepare_exec_attachment, 

55 make_opaque_py, 

56) 

57from cuda.core._utils.cuda_utils cimport HANDLE_RETURN, _parse_fill_value 

58from cuda.core._utils.version cimport cy_binding_version, cy_driver_version 

59  

60from cuda.core.graph._host_callback cimport ( 

61 _is_py_host_trampoline, 

62 _resolve_host_callback, 

63) 

64  

65from cuda.core._utils.cuda_utils import driver, handle_return (empty)

66from cuda.core.typing import GraphConditionalType (empty)

67  

68__all__ = [ (empty)

69 'AllocNode', 

70 'ChildGraphNode', 

71 'ConditionalNode', 

72 'EmptyNode', 

73 'EventRecordNode', 

74 'EventWaitNode', 

75 'ExecutableChildGraphNode', 

76 'ExecutableEventRecordNode', 

77 'ExecutableEventWaitNode', 

78 'ExecutableGraphNode', 

79 'ExecutableHostCallbackNode', 

80 'ExecutableKernelNode', 

81 'ExecutableMemcpyNode', 

82 'ExecutableMemsetNode', 

83 'FreeNode', 

84 'HostCallbackNode', 

85 'IfElseNode', 

86 'IfNode', 

87 'KernelNode', 

88 'MemcpyNode', 

89 'MemsetNode', 

90 'SwitchNode', 

91 'WhileNode', 

92] 

93  

94  

95cdef bint _has_cuGraphNodeGetParams = False (empty)

96cdef bint _version_checked = False (empty)

97  

98  

99cdef void _require_graph_node_update_support() except *: (empty)

100 cdef tuple version = cy_driver_version() 46 ctx1BDKpVXN78lkibfchgOWPQAICLMuvwEFGxyR9)*JqdezSHa

101 if version < (12, 2, 0): 46 ctx1BDKpVXN78lkibfchgOWPQAICLMuvwEFGxyR9)*JqdezSHa

102 raise RuntimeError( 

103 "Graph node mutation requires CUDA driver 12.2 or newer; " 

104 f"using driver version {'.'.join(map(str, version))}" 

105 ) 

106 version = cy_binding_version() 46 ctx1BDKpVXN78lkibfchgOWPQAICLMuvwEFGxyR9)*JqdezSHa

107 if version < (12, 2, 0): 46 ctx1BDKpVXN78lkibfchgOWPQAICLMuvwEFGxyR9)*JqdezSHa

108 raise RuntimeError( 

109 "Graph node mutation requires cuda.bindings 12.2 or newer; " 

110 f"using cuda.bindings version {'.'.join(map(str, version))}" 

111 ) 

112  

113  

114cdef void _set_definition_node_params( (empty)

115 const GraphNodeHandle& h_node, 

116 cydriver.CUgraphNodeParams* params, 

117 OpaqueHandle owner0, 

118 OpaqueHandle owner1=OpaqueHandle(), (empty)

119 cydriver.CUcontext update_ctx=NULL) except *: 

120 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 15 ctx1XN78lkibfchgdea

121 cdef cydriver.CUgraphNode node = as_cu(h_node) 15 ctx1XN78lkibfchgdea

122 if as_cu(h_graph) == NULL: 15 ctx1XN78lkibfchgdea

123 raise RuntimeError("GraphDefinition is no longer valid") 

124 if node == NULL: 15 ctx1XN78lkibfchgdea

125 raise RuntimeError("GraphNode has been destroyed") 

126 _require_graph_node_update_support() 15 ctx1XN78lkibfchgdea

127 cdef cydriver.CUcontext previous_ctx = NULL 15 ctx1XN78lkibfchgdea

128 cdef bint restore_ctx = False 15 ctx1XN78lkibfchgdea

129 cdef PreparedAttachment prepared 

130  

131 HANDLE_RETURN(graph_prepare_attachment( 15 ctx1XN78lkibfchgdea

132 h_graph, owner0, owner1, &prepared)) 

133 if update_ctx != NULL: 16 ctx1jXN78lkibfchgdea

134 with nogil: 8 ctx1bfchgdea

135 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&previous_ctx)) 8 ctx1bfchgdea

136 if previous_ctx != update_ctx: 8 ctx1bfchgdea

137 HANDLE_RETURN(cydriver.cuCtxSetCurrent(update_ctx)) 1 ctx1a

138 restore_ctx = True 1 ctx1a

139 try: 15 ctx1XN78lkibfchgdea

140 with nogil: 15 ctx1XN78lkibfchgdea

141 HANDLE_RETURN(cydriver.cuGraphNodeSetParams(node, params)) 15 ctx1XN78lkibfchgdea

142 finally: 

143 if restore_ctx: 15 ctx1XN78lkibfchgdea

144 with nogil: 1 ctx1a

145 HANDLE_RETURN(cydriver.cuCtxSetCurrent(previous_ctx)) 1 ctx1a

146 HANDLE_RETURN(graph_commit_attachment(prepared, node)) 15 ctx1XN78lkibfchgdea

147  

148  

149cdef void _set_executable_node_params( (empty)

150 const GraphExecHandle& h_exec, 

151 const GraphNodeHandle& h_node, 

152 cydriver.CUgraphNodeParams* params, 

153 OpaqueHandle owner0=OpaqueHandle(), (empty)

154 OpaqueHandle owner1=OpaqueHandle()) except *: (empty)

155 _require_graph_node_update_support() 22 ctx1KpOAICLMuvwEFGxyRJqzSH

156  

157 cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) 22 ctx1KpOAICLMuvwEFGxyRJqzSH

158 cdef cydriver.CUgraphNode node = as_cu(h_node) 22 ctx1KpOAICLMuvwEFGxyRJqzSH

159 if graph_exec == NULL: 22 ctx1KpOAICLMuvwEFGxyRJqzSH

160 raise RuntimeError("Graph has been closed") 

161 if node == NULL: 22 ctx1KpOAICLMuvwEFGxyRJqzSH

162 raise RuntimeError("GraphNode has been destroyed") 

163  

164 cdef PreparedExecAttachment prepared 

165 HANDLE_RETURN(graph_prepare_exec_attachment( 22 ctx1KpOAICLMuvwEFGxyRJqzSH

166 h_exec, owner0, owner1, &prepared)) 

167  

168 cdef cydriver.CUresult status 

169 with nogil: 22 ctx1KpOAICLMuvwEFGxyRJqzSH

170 status = cydriver.cuGraphExecNodeSetParams( 22 ctx1KpOAICLMuvwEFGxyRJqzSH

171 graph_exec, node, params) 

172 if status == cydriver.CUDA_SUCCESS: 22 ctx1KpOAICLMuvwEFGxyRJqzSH

173 graph_commit_exec_attachment(prepared) 21 ctx1KpOAICLMuvwEFGxyRJqSH

174 HANDLE_RETURN(status) 22 ctx1KpOAICLMuvwEFGxyRJqzSH

175  

176  

177cdef bint _get_executable_node_enabled( (empty)

178 const GraphExecHandle& h_exec, 

179 const GraphNodeHandle& h_node) except *: 

180 _require_graph_node_update_support() 3 ctx1WPQ

181  

182 cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) 3 ctx1WPQ

183 cdef cydriver.CUgraphNode node = as_cu(h_node) 3 ctx1WPQ

184 cdef unsigned int enabled 

185 if graph_exec == NULL: 3 ctx1WPQ

186 raise RuntimeError("Graph has been closed") 

187 if node == NULL: 3 ctx1WPQ

188 raise RuntimeError("GraphNode has been destroyed") 

189 with nogil: 3 ctx1WPQ

190 HANDLE_RETURN(cydriver.cuGraphNodeGetEnabled( 3 ctx1WPQ

191 graph_exec, node, &enabled)) 

192 return enabled != 0 3 ctx1WPQ

193  

194  

195cdef void _set_executable_node_enabled( (empty)

196 const GraphExecHandle& h_exec, 

197 const GraphNodeHandle& h_node, 

198 bint enabled) except *: 

199 _require_graph_node_update_support() 3 ctx1WPQ

200  

201 cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) 3 ctx1WPQ

202 cdef cydriver.CUgraphNode node = as_cu(h_node) 3 ctx1WPQ

203 if graph_exec == NULL: 3 ctx1WPQ

204 raise RuntimeError("Graph has been closed") 

205 if node == NULL: 3 ctx1WPQ

206 raise RuntimeError("GraphNode has been destroyed") 

207 with nogil: 3 ctx1WPQ

208 HANDLE_RETURN(cydriver.cuGraphNodeSetEnabled( 3 ctx1WPQ

209 graph_exec, node, <unsigned int>enabled)) 

210  

211  

212cdef bint _check_node_get_params(): (empty)

213 global _has_cuGraphNodeGetParams, _version_checked 

214 if not _version_checked: 28 ctx10Y123Z45-bfchgrst!#mnoTUde6a

215 from cuda.core._utils.version import binding_version, driver_version 2 ctx1ga

216 _has_cuGraphNodeGetParams = ( 

217 driver_version() >= (13, 2, 0) and binding_version() >= (13, 2, 0) 2 ctx1ga

218 ) 

219 _version_checked = True 2 ctx1ga

220 return _has_cuGraphNodeGetParams 28 ctx10Y123Z45-bfchgrst!#mnoTUde6a

221  

222  

223cdef void _reject_unsupported_kernel_node( (empty)

224 cydriver.CUgraphNode node) except *: 

225 cdef cydriver.CUkernelNodeAttrValue cluster 

226 cdef cydriver.CUkernelNodeAttrValue cooperative 

227  

228 c_memset(&cluster, 0, sizeof(cluster)) 5 ctx1lki)*

229 c_memset(&cooperative, 0, sizeof(cooperative)) 5 ctx1lki)*

230 with nogil: 5 ctx1lki)*

231 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( 5 ctx1lki)*

232 node, <cydriver.CUkernelNodeAttrID>( 

233 cydriver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION), 

234 &cluster)) 

235 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( 5 ctx1lki)*

236 node, <cydriver.CUkernelNodeAttrID>( 

237 cydriver.CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE), 

238 &cooperative)) 

239 if (cluster.clusterDim.x != 0 or cluster.clusterDim.y != 0 or 5 ctx1lki)*

240 cluster.clusterDim.z != 0 or cooperative.cooperative != 0): 5 ctx1lki)*

241 raise NotImplementedError( 

242 "updating clustered or cooperative kernel nodes is not supported") 

243  

244  

245cdef bint _is_supported_memcpy_descriptor( (empty)

246 cydriver.CUDA_MEMCPY3D* params) noexcept nogil: 

247 return ( 

248 (params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST or 13 ctx1bfcrstmnode6a

249 params.srcMemoryType == cydriver.CU_MEMORYTYPE_DEVICE) 13 ctx1bfcrstmnode6a

250 and (params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST or 13 ctx1bfcrstmnode6a

251 params.dstMemoryType == cydriver.CU_MEMORYTYPE_DEVICE) 13 ctx1bfcrstmnode6a

252 and params.srcXInBytes == 0 13 ctx1bfcrstmnode6a

253 and params.srcY == 0 12 ctx1bfcrstmnodea

254 and params.srcZ == 0 12 ctx1bfcrstmnodea

255 and params.srcLOD == 0 12 ctx1bfcrstmnodea

256 and params.srcPitch == 0 12 ctx1bfcrstmnodea

257 and params.srcHeight == 0 12 ctx1bfcrstmnodea

258 and params.dstXInBytes == 0 12 ctx1bfcrstmnodea

259 and params.dstY == 0 12 ctx1bfcrstmnodea

260 and params.dstZ == 0 12 ctx1bfcrstmnodea

261 and params.dstLOD == 0 12 ctx1bfcrstmnodea

262 and params.dstPitch == 0 12 ctx1bfcrstmnodea

263 and params.dstHeight == 0 12 ctx1bfcrstmnodea

264 and params.Height == 1 12 ctx1bfcrstmnodea

265 and params.Depth == 1 12 ctx1bfcrstmnodea

266 and params.reserved0 == NULL 12 ctx1bfcrstmnodea

267 and params.reserved1 == NULL 12 ctx1bfcrstmnodea

268 ) 

269  

270  

271cdef class EmptyNode(GraphNode): 

272 """An empty (synchronization) node.""" 

273  

274 @staticmethod (empty)

275 cdef EmptyNode _create_impl(GraphNodeHandle h_node): 

276 cdef EmptyNode n = EmptyNode.__new__(EmptyNode) 177 ctx2|j}jSeTe~j$ % ' ( UeVeWeakbkckXeIbYeabJbZe0e1e2e3eKb4eEbLb5edkMb6eNb7e8e9e!eek#e$efk%e?f@f[f]f^fgkajhkikjk_fkklk}bJ fggg'eObbj(ePbQb)eRb*eSb+eTb,eUb-esbAdBdwdmd.e/ekcVbFb:e;e=eWbbb?eXb@eYb[ [eZb+ cbdb^ 0b1b2b3b. ]e4b^e5b_e6b`e7b8b{e9b|e!b}e#b~e$baftbCdDdxdndbfcflc%bGbdfefff'bebgf(bhf)b] if*b, fbgb_ +b,b-b.b/ jf/bkf:blf;bmf=bnf?bof@bpf[bqf]brf^bsf_btf`b

277 n._h_node = h_node 177 ctx2|j}jSeTe~j$ % ' ( UeVeWeakbkckXeIbYeabJbZe0e1e2e3eKb4eEbLb5edkMb6eNb7e8e9e!eek#e$efk%e?f@f[f]f^fgkajhkikjk_fkklk}bJ fggg'eObbj(ePbQb)eRb*eSb+eTb,eUb-esbAdBdwdmd.e/ekcVbFb:e;e=eWbbb?eXb@eYb[ [eZb+ cbdb^ 0b1b2b3b. ]e4b^e5b_e6b`e7b8b{e9b|e!b}e#b~e$baftbCdDdxdndbfcflc%bGbdfefff'bebgf(bhf)b] if*b, fbgb_ +b,b-b.b/ jf/bkf:blf;bmf=bnf?bof@bpf[bqf]brf^bsf_btf`b

278 return n 177 ctx2|j}jSeTe~j$ % ' ( UeVeWeakbkckXeIbYeabJbZe0e1e2e3eKb4eEbLb5edkMb6eNb7e8e9e!eek#e$efk%e?f@f[f]f^fgkajhkikjk_fkklk}bJ fggg'eObbj(ePbQb)eRb*eSb+eTb,eUb-esbAdBdwdmd.e/ekcVbFb:e;e=eWbbb?eXb@eYb[ [eZb+ cbdb^ 0b1b2b3b. ]e4b^e5b_e6b`e7b8b{e9b|e!b}e#b~e$baftbCdDdxdndbfcflc%bGbdfefff'bebgf(bhf)b] if*b, fbgb_ +b,b-b.b/ jf/bkf:blf;bmf=bnf?bof@bpf[bqf]brf^bsf_btf`b

279  

280 def __repr__(self) -> str: 

281 return f"<EmptyNode handle=0x{as_intptr(self._h_node):x}>" 3 ctx2ajbjyk

282  

283  

284cdef class KernelNode(GraphNode): 

285 """A kernel launch node. 

286  

287 Properties 

288 ---------- 

289 grid : tuple of int 

290 Grid dimensions (gridDimX, gridDimY, gridDimZ). 

291 block : tuple of int 

292 Block dimensions (blockDimX, blockDimY, blockDimZ). 

293 shmem_size : int 

294 Dynamic shared memory size in bytes. 

295 kernel : Kernel 

296 The kernel object for this launch node. 

297 config : LaunchConfig 

298 A LaunchConfig reconstructed from this node's parameters. 

299 """ 

300  

301 @staticmethod (empty)

302 cdef KernelNode _create_with_params(GraphNodeHandle h_node, 

303 tuple grid, tuple block, unsigned int shmem_size, 

304 KernelHandle h_kernel): 

305 """Create from known params (called by launch() builder).""" 

306 cdef KernelNode n = KernelNode.__new__(KernelNode) 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

307 n._h_node = h_node 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

308 n._grid = grid 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

309 n._block = block 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

310 n._shmem_size = shmem_size 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

311 n._h_kernel = h_kernel 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

312 return n 183 ctx2UdDhVdWdXdufEhFhGhHhIhJhKhEdvfFdwfGdxfHdyfIdzfJdAfKdLhLdydMdNd~bMhNhpgzeOhPh` ?f@f[f]f^f= p l k i QhRhShqgrgsgW u v w }b) `f* q zdz ThBfUhCfVhacOdDfWhPdQdodEfFfGfHfIfXhJfYhKfZhsbkcLf0hhbMf1hNf2hOfPfQf{b2d3h4h[ } 5h6hRf7h+ : Sf8hTf9hUf!hVf#hbcRdWf$hSdTdpdXfYfZf0f1f%h2f'h3f(htblc4f)hib5f*h6f+h7f8f9f|b3d,h-h] ~ .h/h!f:h, ; #f;h$f=h%f?h'f@h(f[h)f]h*f^h+f_h,f`h-f{h.f|h

313  

314 @staticmethod (empty)

315 cdef KernelNode _create_from_driver(GraphNodeHandle h_node): 

316 """Create by fetching params from the driver (called by _create factory).""" 

317 cdef cydriver.CUgraphNode node = as_cu(h_node) 12 ctx2UdVdWdXdEdLdydMdNd~b` =

318 cdef cydriver.CUDA_KERNEL_NODE_PARAMS params 

319 with nogil: 12 ctx2UdVdWdXdEdLdydMdNd~b` =

320 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams(node, &params)) 12 ctx2UdVdWdXdEdLdydMdNd~b` =

321 cdef KernelHandle h_kernel = create_kernel_handle_ref(params.kern) 12 ctx2UdVdWdXdEdLdydMdNd~b` =

322 return KernelNode._create_with_params( 12 ctx2UdVdWdXdEdLdydMdNd~b` =

323 h_node, 

324 (params.gridDimX, params.gridDimY, params.gridDimZ), 12 ctx2UdVdWdXdEdLdydMdNd~b` =

325 (params.blockDimX, params.blockDimY, params.blockDimZ), 12 ctx2UdVdWdXdEdLdydMdNd~b` =

326 params.sharedMemBytes, 

327 h_kernel) 

328  

329 def __repr__(self) -> str: 

330 return (f"<KernelNode handle=0x{as_intptr(self._h_node):x}" 3 ctx2p q nk

331 f" kernel=0x{as_intptr(self._h_kernel):x}>") 3 ctx2p q nk

332  

333 def update( (empty)

334 self, 

335 *, 

336 config: LaunchConfig | None = None, (empty)

337 kernel: Kernel | None = None, (empty)

338 args=None, (empty)

339 ) -> None: 

340 """Replace selected kernel launch parameters. 

341  

342 Omitted parameters preserve their current values. Changing ``kernel`` 

343 requires ``args``, including ``args=()`` for a no-argument kernel. 

344 Clustered and cooperative kernel nodes are not supported. 

345  

346 .. warning:: 

347  

348 Use caution when a retained kernel argument directly or indirectly 

349 owns a graph. Any reference cycle involving the argument and a 

350 graph that retains it cannot be broken by Python's cyclic garbage 

351 collector. Use a weak reference to break such cycles. 

352 """ 

353 GN_check_valid(self) 9 ctx2l k i qgrgsg) * zd

354 cdef LaunchConfig c_config 

355 cdef Kernel c_kernel 

356 cdef ParamHolder arg_holder 

357 cdef object kernel_args 

358 cdef KernelHandle h_kernel = self._h_kernel 6 ctx2l k i ) * zd

359 cdef OpaqueHandle kernel_owner 

360 cdef OpaqueHandle args_owner 

361 cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) 6 ctx2l k i ) * zd

362 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 6 ctx2l k i ) * zd

363 cdef cydriver.CUgraphNodeParams params 

364  

365 if config is not None: 6 ctx2l k i ) * zd

366 c_config = config 2 ctx2k zd

367 if (c_config.cluster is not None or 2 ctx2k zd

368 c_config.is_cooperative): 2 ctx2k zd

369 raise NotImplementedError( 1 ctx2zd

370 "updating clustered or cooperative kernel nodes is not " 

371 "supported") 

372 _require_graph_node_update_support() 5 ctx1lki)*

373 _reject_unsupported_kernel_node(node) 5 ctx1lki)*

374 if kernel is not None: 5 ctx1lki)*

375 if args is None: 2 ctx1i*

376 raise ValueError("changing kernel requires args") 1 ctx1*

377 c_kernel = kernel 1 ctx1i

378 h_kernel = c_kernel._h_kernel 1 ctx1i

379 if args is not None: 4 ctx1lki)

380 arg_holder = ParamHolder(args) 3 ctx1li)

381  

382 c_memset(&params, 0, sizeof(params)) 3 ctx1lki

383 params.type = cydriver.CU_GRAPH_NODE_TYPE_KERNEL 3 ctx1lki

384 with nogil: 3 ctx1lki

385 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams( 3 ctx1lki

386 node, <cydriver.CUDA_KERNEL_NODE_PARAMS*>&params.kernel)) 

387 HANDLE_RETURN(graph_get_attachment( 3 ctx1lki

388 h_graph, node, &kernel_owner, &args_owner)) 

389  

390 if config is not None: 3 ctx1lki

391 params.kernel.gridDimX = c_config.grid[0] 1 ctx1k

392 params.kernel.gridDimY = c_config.grid[1] 1 ctx1k

393 params.kernel.gridDimZ = c_config.grid[2] 1 ctx1k

394 params.kernel.blockDimX = c_config.block[0] 1 ctx1k

395 params.kernel.blockDimY = c_config.block[1] 1 ctx1k

396 params.kernel.blockDimZ = c_config.block[2] 1 ctx1k

397 params.kernel.sharedMemBytes = c_config.shmem_size 1 ctx1k

398 if kernel is not None: 3 ctx1lki

399 params.kernel.kern = as_cu(h_kernel) 1 ctx1i

400 params.kernel.func = <cydriver.CUfunction>NULL 1 ctx1i

401 params.kernel.ctx = <cydriver.CUcontext>NULL 1 ctx1i

402 kernel_owner = h_kernel 1 ctx1i

403 if args is not None: 3 ctx1lki

404 params.kernel.kernelParams = <void**><uintptr_t>arg_holder.ptr 2 ctx1li

405 params.kernel.extra = NULL 2 ctx1li

406 kernel_args = arg_holder.kernel_args 2 ctx1li

407 if kernel_args is None: 2 ctx1li

408 args_owner = OpaqueHandle() 1 ctx1i

409 else: 

410 args_owner = make_opaque_py(kernel_args) 1 ctx1l

411  

412 _set_definition_node_params( 3 ctx1lki

413 self._h_node, &params, kernel_owner, args_owner) 

414 self._grid = ( 3 ctx1lki

415 params.kernel.gridDimX, 3 ctx1lki

416 params.kernel.gridDimY, 3 ctx1lki

417 params.kernel.gridDimZ, 3 ctx1lki

418 ) 

419 self._block = ( 3 ctx1lki

420 params.kernel.blockDimX, 3 ctx1lki

421 params.kernel.blockDimY, 3 ctx1lki

422 params.kernel.blockDimZ, 3 ctx1lki

423 ) 

424 self._shmem_size = params.kernel.sharedMemBytes 3 ctx1lki

425 self._h_kernel = h_kernel 3 ctx1lki

426  

427 @property 

428 def grid(self) -> tuple[int, int, int]: 

429 """Grid dimensions as a 3-tuple (gridDimX, gridDimY, gridDimZ).""" 

430 return self._grid 2 ctx2cijb

431  

432 @property 

433 def block(self) -> tuple[int, int, int]: 

434 """Block dimensions as a 3-tuple (blockDimX, blockDimY, blockDimZ).""" 

435 return self._block 2 ctx2cijb

436  

437 @property 

438 def shmem_size(self) -> int: 

439 """Dynamic shared memory size in bytes.""" 

440 return self._shmem_size 2 ctx2cijb

441  

442 @property 

443 def kernel(self) -> Kernel: 

444 """The Kernel object for this launch node.""" 

445 return Kernel._from_handle(self._h_kernel) 13 ctx2cijbpgzel k i u v w ) `f*

446  

447 @property 

448 def config(self) -> LaunchConfig: 

449 """A LaunchConfig reconstructed from this node's grid, block, and shmem_size. 

450  

451 Note: cluster dimensions and is_cooperative are not preserved 

452 by the CUDA driver's kernel node params, so they are not included. 

453 """ 

454 return LaunchConfig(grid=self._grid, block=self._block, 11 ctx2cijbl k i u v w ) `f*

455 shmem_size=self._shmem_size) 11 ctx2cijbl k i u v w ) `f*

456  

457  

458cdef class AllocNode(GraphNode): 

459 """A memory allocation node. 

460  

461 Properties 

462 ---------- 

463 dptr : int 

464 The device pointer for the allocation. 

465 bytesize : int 

466 The number of bytes allocated. 

467 device_id : int 

468 The device on which the allocation was made. 

469 memory_type : GraphMemoryType | str 

470 The type of memory allocated. 

471 peer_access : tuple of int 

472 Device IDs that have read-write access to this allocation. 

473 """ 

474  

475 @staticmethod (empty)

476 cdef AllocNode _create_with_params(GraphNodeHandle h_node, 

477 cydriver.CUdeviceptr dptr, size_t bytesize, 

478 int device_id, str memory_type, tuple peer_access): 

479 """Create from known params (called by allocate() builder).""" 

480 cdef AllocNode n = AllocNode.__new__(AllocNode) 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

481 n._h_node = h_node 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

482 n._dptr = dptr 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

483 n._bytesize = bytesize 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

484 n._device_id = device_id 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

485 n._memory_type = memory_type 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

486 n._peer_access = peer_access 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

487 return n 448 ctx2hgig4dtgugvgwgSexgTeygzg5d6d7d8d9d$ % ' ( ubvbwbxbAgBgCgUeVeWeDgEgXeAeBe!dFdIbmcncocpcqbFgrbGgYeccCedcDeec#djbGdabJbkbqclbrcmbscnbtcHgZeIg0eJgKgLg1eMg2eNgOgPgQg3eEeFe$dHdKbucvcwcxcycRgzcSgAc4eBcGeCcHeDc%dEcIdEbLbFcGcHcIcJcKcLcMcNcTgOcUgPc5eQcIeRcJeSc'dTcJdMbUcVcWcXcYcZc0c1cVgWg6eKeLe(dKdNb2c3c4c5cXg7eYg8eZg0g1g9e2g!e3g4g5g#e6g$e7g8g%ejg9g)d*dYd!g'e+dOb6c#g(e,dPb7cacMeNe-dZd$g%gOdQb8c'g(g)g)e.dRb9c*g*e/dSb!c+g+e:dTb#c,g,e;dUb$c-esbAdBdwdmd.e/ekcVbFb:e;e-g=e=dWb%chbqdrdfc?d@dbbyb[d]d.g?e^dXb'c/g@e_dYb(c{b[ } :g[e`dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c;g]e{d4b.c=g^e|d5b/c?g_e}d6b:c@g`e~d7b;cbcOePeae0d[g]gRd8b=c^g_g`g{ebe9b?c{g|ece!b@c|g}ede#b[c}g~eee$b]caftbCdDdxdndbfcflc%bGbdfef~gfffe'b^cibsdtdgcgeheebBbiejeahgfke(b_cbhhfle)b`c|b] ~ chifme*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~caddhjfne/bbdehkfoe:bcdfhlfpe;bddghmfqe=bedhhnfre?bfdihofse@bgdjhpfte[bhdkhqfue]bidlhrfve^bjdmhsfwe_bkdnhtfxe`bld

488  

489 @staticmethod (empty)

490 cdef AllocNode _create_from_driver(GraphNodeHandle h_node): 

491 """Create by fetching params from the driver (called by _create factory).""" 

492 cdef cydriver.CUgraphNode node = as_cu(h_node) 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

493 cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS params 

494 with nogil: 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

495 HANDLE_RETURN(cydriver.cuGraphMemAllocNodeGetParams(node, &params)) 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

496  

497 cdef str memory_type 

498 if params.poolProps.allocType == cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_PINNED: 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

499 if params.poolProps.location.type == cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST: 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

500 memory_type = "host" 

501 else: 

502 memory_type = "device" 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

503 else: 

504 IF CUDA_CORE_BUILD_MAJOR >= 13: 

505 if params.poolProps.allocType == cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_MANAGED: 

506 memory_type = "managed" 

507 else: 

508 memory_type = "device" 

509 ELSE: 

510 memory_type = "device" 

511  

512 cdef list peer_ids = [] 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

513 cdef size_t i 

514 for i in range(params.accessDescCount): 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

515 peer_ids.append(<int>params.accessDescs[i].location.id) 

516  

517 return AllocNode._create_with_params( 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

518 h_node, params.dptr, params.bytesize, 

519 <int>params.poolProps.location.id, memory_type, tuple(peer_ids)) 34 ctx2qbrbccdcecjbabkblbmbnbyczcAcBcCcDcEcEbFcHcJcLcNcOcPcQcRcScTcUcWcYc0c

520  

521 def __repr__(self) -> str: 

522 return (f"<AllocNode handle=0x{as_intptr(self._h_node):x}" 1 ctx2ok

523 f" dptr=0x{self._dptr:x} size={self._bytesize}>") 1 ctx2ok

524  

525 @property 

526 def dptr(self) -> int: 

527 """The device pointer for the allocation.""" 

528 return self._dptr 228 ctx2hgig4d5d6d7d8d9d$ % ' ( ubvbwbxb]i^i!dIbmcncocpcqbrb#dJbqcrcsctc$dKbucvcwcxc%dLbGcIcKcMc'dMbVcXcZc1c(dNb2c3c4c5cjg+dOb6c,dPb7c-dQb8c.dRb9c/dSb!c:dTb#c;dUb$cwdVbFb=dWb%chbqdrdfc?d@dbbyb[d]d^dXb'c_dYb(c{b[ } `dZb)c+ cbdb^ 0b1b2b3b: zbAbob*c+c. ,c-c{d4b.c|d5b/c}d6b:c~d7b;cae8b=cbe9b?cce!b@cde#b[cee$b]cxd%bGbfe'b^cibsdtdgcgeheebBbiejeke(b_cle)b`c|b] ~ me*b{c, fbgb_ +b,b-b.b; CbDbpb|c}c/ ~cadne/bbdoe:bcdpe;bddqe=bedre?bfdse@bgdte[bhdue]bidve^bjdwe_bkdxe`bld

529  

530 @property 

531 def bytesize(self) -> int: 

532 """The number of bytes allocated.""" 

533 return self._bytesize 4 ctx2]i^iqbrb

534  

535 @property 

536 def device_id(self) -> int: 

537 """The device on which the allocation was made.""" 

538 return self._device_id 4 ctx2]i^iqbrb

539  

540 @property 

541 def memory_type(self) -> str: 

542 """The type of memory: ``"device"``, ``"host"``, or ``"managed"``.""" 

543 return self._memory_type 4 ctx2]i^iqbrb

544  

545 @property 

546 def peer_access(self) -> tuple[int, ...]: 

547 """Device IDs with read-write access to this allocation.""" 

548 return self._peer_access 4 ctx2]i^iqbrb

549  

550  

551cdef class FreeNode(GraphNode): 

552 """A memory deallocation node. 

553  

554 Properties 

555 ---------- 

556 dptr : int 

557 The device pointer being freed. 

558 """ 

559  

560 @staticmethod (empty)

561 cdef FreeNode _create_with_params(GraphNodeHandle h_node, 

562 cydriver.CUdeviceptr dptr): 

563 """Create from known params (called by deallocate() builder).""" 

564 cdef FreeNode n = FreeNode.__new__(FreeNode) 79 ctx24d5d6d7d8d9d$ % ' ( ubvbwbxb!d#d$d%d'd(d+d,d-d.d/d:d;dwd=dhbqdrdfc?d@dbbyb[d]d^d_d{b`d{d|d}d~daebecedeeexdfeibsdtdgcgeheebBbiejekele|bmeneoepeqereseteuevewexe

565 n._h_node = h_node 79 ctx24d5d6d7d8d9d$ % ' ( ubvbwbxb!d#d$d%d'd(d+d,d-d.d/d:d;dwd=dhbqdrdfc?d@dbbyb[d]d^d_d{b`d{d|d}d~daebecedeeexdfeibsdtdgcgeheebBbiejekele|bmeneoepeqereseteuevewexe

566 n._dptr = dptr 79 ctx24d5d6d7d8d9d$ % ' ( ubvbwbxb!d#d$d%d'd(d+d,d-d.d/d:d;dwd=dhbqdrdfc?d@dbbyb[d]d^d_d{b`d{d|d}d~daebecedeeexdfeibsdtdgcgeheebBbiejekele|bmeneoepeqereseteuevewexe

567 return n 79 ctx24d5d6d7d8d9d$ % ' ( ubvbwbxb!d#d$d%d'd(d+d,d-d.d/d:d;dwd=dhbqdrdfc?d@dbbyb[d]d^d_d{b`d{d|d}d~daebecedeeexdfeibsdtdgcgeheebBbiejekele|bmeneoepeqereseteuevewexe

568  

569 @staticmethod (empty)

570 cdef FreeNode _create_from_driver(GraphNodeHandle h_node): 

571 """Create by fetching params from the driver (called by _create factory).""" 

572 cdef cydriver.CUgraphNode node = as_cu(h_node) 

573 cdef cydriver.CUdeviceptr dptr 

574 with nogil: 

575 HANDLE_RETURN(cydriver.cuGraphMemFreeNodeGetParams(node, &dptr)) 

576 return FreeNode._create_with_params(h_node, dptr) 

577  

578 def __repr__(self) -> str: 

579 return f"<FreeNode handle=0x{as_intptr(self._h_node):x} dptr=0x{self._dptr:x}>" 1 ctx2zk

580  

581 @property 

582 def dptr(self) -> int: 

583 """The device pointer being freed.""" 

584 return self._dptr 2 ctx2Akec

585  

586  

587cdef class MemsetNode(GraphNode): 

588 """A memset node. 

589  

590 Properties 

591 ---------- 

592 dptr : int 

593 The destination device pointer. 

594 value : int 

595 The fill value. 

596 element_size : int 

597 Element size in bytes (1, 2, or 4). 

598 width : int 

599 Width of the row in elements. 

600 height : int 

601 Number of rows. 

602 pitch : int 

603 Pitch in bytes (unused if height is 1). 

604 """ 

605  

606 @staticmethod (empty)

607 cdef MemsetNode _create_with_params(GraphNodeHandle h_node, 

608 cydriver.CUdeviceptr dptr, unsigned int value, 

609 unsigned int element_size, size_t width, 

610 size_t height, size_t pitch): 

611 """Create from known params (called by memset() builder).""" 

612 cdef MemsetNode n = MemsetNode.__new__(MemsetNode) 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

613 n._h_node = h_node 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

614 n._dptr = dptr 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

615 n._value = value 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

616 n._element_size = element_size 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

617 n._width = width 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

618 n._height = height 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

619 n._pitch = pitch 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

620 return n 109 ctx2$ % ' ( ubvbwbxbmcncocpcqcrcsctcucvcwcxcGcIcKcMcVcXcZc1c2c3c4c5ckglgmg= Qeh g ! # {f|fQ x y T U uda 6c7c8c9c!c#c$cFb%cyb'c(c} )c: zbAbob*c+c. ,c-c.c/c:c;c=c?c@c[c]cGb^cBb_c`c~ {c; CbDbpb|c}c/ ~cadbdcdddedfdgdhdidjdkdld

621  

622 @staticmethod (empty)

623 cdef MemsetNode _create_from_driver(GraphNodeHandle h_node): 

624 """Create by fetching params from the driver (called by _create factory).""" 

625 cdef cydriver.CUgraphNode node = as_cu(h_node) 1 ctx1=

626 cdef cydriver.CUDA_MEMSET_NODE_PARAMS params 

627 with nogil: 1 ctx1=

628 HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams(node, &params)) 1 ctx1=

629 return MemsetNode._create_with_params( 1 ctx1=

630 h_node, params.dst, params.value, 

631 params.elementSize, params.width, params.height, params.pitch) 1 ctx1=

632  

633 def __repr__(self) -> str: 

634 return (f"<MemsetNode handle=0x{as_intptr(self._h_node):x}" 1 ctx2pk

635 f" dptr=0x{self._dptr:x} value={self._value}>") 1 ctx2pk

636  

637 def update( (empty)

638 self, 

639 *, 

640 dst: Buffer | int | None = None, (empty)

641 value=None, (empty)

642 width: int | None = None, (empty)

643 height: int | None = None, (empty)

644 pitch: int | None = None, (empty)

645 dst_owner=None, (empty)

646 ) -> None: 

647 """Replace selected memset parameters. 

648  

649 Omitted parameters preserve their current values. ``dst_owner`` may 

650 only accompany a raw-address ``dst``. 

651  

652 With CUDA 12.2 through 13.1, the node's intended CUDA context must be 

653 current when this method is called. CUDA driver and ``cuda.bindings`` 

654 versions 13.2 and newer preserve the recorded context automatically. 

655  

656 .. warning:: 

657  

658 Use caution when a retained operand owner directly or indirectly 

659 owns a graph. Any reference cycle involving the owner and a graph 

660 that retains it cannot be broken by Python's cyclic garbage 

661 collector. Use a weak reference to break such cycles. 

662 """ 

663 cdef OpaqueHandle dst_attachment_owner 

664 GN_check_valid(self) 9 ctx2h g ! # {f|fT U a

665 cdef GraphHandle h_graph 

666 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 7 ctx1hg!#TUa

667 cdef cydriver.CUcontext ctx = NULL 7 ctx1hg!#TUa

668 cdef cydriver.CUDA_MEMSET_NODE_PARAMS current 

669 cdef cydriver.CUgraphNodeParams params 

670 cdef object queried 

671  

672 if dst is None and dst_owner is not None: 7 ctx1hg!#TUa

673 raise ValueError("dst_owner requires dst") 

674 if (dst is None and value is None and width is None and 7 ctx1hg!#TUa

675 height is None and pitch is None): 

676 return 

677  

678 c_memset(&params, 0, sizeof(params)) 7 ctx1hg!#TUa

679 params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMSET 7 ctx1hg!#TUa

680 with nogil: 7 ctx1hg!#TUa

681 HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams( 7 ctx1hg!#TUa

682 node, &current)) 

683 if _check_node_get_params(): 7 ctx1hg!#TUa

684 queried = handle_return(driver.cuGraphNodeGetParams( 7 ctx1hg!#TUa

685 <uintptr_t>node)) 7 ctx1hg!#TUa

686 ctx = <cydriver.CUcontext><uintptr_t>int(queried.memset.ctx) 7 ctx1hg!#TUa

687 else: 

688 with nogil: 

689 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) 

690  

691 cdef cydriver.CUdeviceptr c_dst = current.dst 7 ctx1hg!#TUa

692 cdef unsigned int c_value = current.value 7 ctx1hg!#TUa

693 cdef unsigned int c_element_size = current.elementSize 7 ctx1hg!#TUa

694 cdef size_t c_width = current.width 7 ctx1hg!#TUa

695 cdef size_t c_height = current.height 7 ctx1hg!#TUa

696 cdef size_t c_pitch = current.pitch 7 ctx1hg!#TUa

697  

698 if dst is None: 7 ctx1hg!#TUa

699 h_graph = graph_node_get_graph(self._h_node) 4 ctx1gTUa

700 HANDLE_RETURN(graph_get_attachment( 4 ctx1gTUa

701 h_graph, node, 

702 &dst_attachment_owner, NULL)) 

703 else: 

704 dst_attachment_owner = _resolve_memcpy_operand( 3 ctx1h!#

705 dst, dst_owner, "dst", &c_dst) 3 ctx1h!#

706  

707 if value is not None: 5 ctx1hgTUa

708 c_value, c_element_size = _parse_fill_value(value) 5 ctx1hgTUa

709 if width is not None: 3 ctx1hga

710 c_width = width 

711 if height is not None: 3 ctx1hga

712 c_height = height 

713 if pitch is not None: 3 ctx1hga

714 c_pitch = pitch 

715  

716 params.memset.dst = c_dst 3 ctx1hga

717 params.memset.value = c_value 3 ctx1hga

718 params.memset.elementSize = c_element_size 3 ctx1hga

719 params.memset.width = c_width 3 ctx1hga

720 params.memset.height = c_height 3 ctx1hga

721 params.memset.pitch = c_pitch 3 ctx1hga

722 params.memset.ctx = ctx 3 ctx1hga

723  

724 _set_definition_node_params( 3 ctx1hga

725 self._h_node, &params, dst_attachment_owner, 

726 OpaqueHandle(), params.memset.ctx) 

727 self._dptr = c_dst 3 ctx1hga

728 self._value = c_value 3 ctx1hga

729 self._element_size = c_element_size 3 ctx1hga

730 self._width = c_width 3 ctx1hga

731 self._height = c_height 3 ctx1hga

732 self._pitch = c_pitch 3 ctx1hga

733  

734 @property 

735 def dptr(self) -> int: 

736 """The destination device pointer.""" 

737 return self._dptr 15 ctx2dieifigikblbmbnbQeh g x y T U

738  

739 @property 

740 def value(self) -> int: 

741 """The fill value.""" 

742 return self._value 15 ctx2dieifigikblbmbnbQeh g x y T U

743  

744 @property 

745 def element_size(self) -> int: 

746 """Element size in bytes (1, 2, or 4).""" 

747 return self._element_size 14 ctx2dieifigikblbmbnbh g x y T U

748  

749 @property 

750 def width(self) -> int: 

751 """Width of the row in elements.""" 

752 return self._width 15 ctx2dieifigikblbmbnbQeh g x y T U

753  

754 @property 

755 def height(self) -> int: 

756 """Number of rows.""" 

757 return self._height 14 ctx2dieifigikblbmbnbh g x y T U

758  

759 @property 

760 def pitch(self) -> int: 

761 """Pitch in bytes (unused if height is 1).""" 

762 return self._pitch 14 ctx2dieifigikblbmbnbh g x y T U

763  

764  

765cdef class MemcpyNode(GraphNode): 

766 """A memcpy node. 

767  

768 Properties 

769 ---------- 

770 dst : int 

771 The destination pointer. 

772 src : int 

773 The source pointer. 

774 size : int 

775 The number of bytes copied. 

776 """ 

777  

778 @staticmethod (empty)

779 cdef MemcpyNode _create_with_params(GraphNodeHandle h_node, 

780 cydriver.CUdeviceptr dst, cydriver.CUdeviceptr src, 

781 size_t size, cydriver.CUmemorytype dst_type, 

782 cydriver.CUmemorytype src_type): 

783 """Create from known params (called by memcpy() builder).""" 

784 cdef MemcpyNode n = MemcpyNode.__new__(MemcpyNode) 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

785 n._h_node = h_node 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

786 n._dst = dst 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

787 n._src = src 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

788 n._size = size 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

789 n._dst_type = dst_type 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

790 n._src_type = src_type 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

791 return n 99 ctx2$ % ' ( IbJbKbLbMbNbohph1dqhrhshthuhvhb f c r s t /f:f;fP E F G m n o d e 6 uda ObPbQbRbSbTbUbVbWbbbXbYb[ Zb+ cbdb^ 0b1b2b3b. 4b5b6b7b8b9b!b#b$b%b'beb(b)b] *b, fbgb_ +b,b-b.b/ /b:b;b=b?b@b[b]b^b_b`b

792  

793 @staticmethod (empty)

794 cdef MemcpyNode _create_from_driver(GraphNodeHandle h_node): 

795 """Create by fetching params from the driver (called by _create factory).""" 

796 cdef cydriver.CUgraphNode node = as_cu(h_node) 

797 cdef cydriver.CUDA_MEMCPY3D params 

798 with nogil: 

799 HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams(node, &params)) 

800  

801 cdef cydriver.CUdeviceptr dst 

802 cdef cydriver.CUdeviceptr src 

803 if params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

804 dst = <cydriver.CUdeviceptr><uintptr_t>params.dstHost 

805 else: 

806 dst = params.dstDevice 

807 if params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

808 src = <cydriver.CUdeviceptr><uintptr_t>params.srcHost 

809 else: 

810 src = params.srcDevice 

811  

812 return MemcpyNode._create_with_params( 

813 h_node, dst, src, params.WidthInBytes, 

814 params.dstMemoryType, params.srcMemoryType) 

815  

816 def __repr__(self) -> str: 

817 cdef str dt = "H" if self._dst_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1 ctx2cj

818 cdef str st = "H" if self._src_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1 ctx2cj

819 return (f"<MemcpyNode handle=0x{as_intptr(self._h_node):x}" 1 ctx2cj

820 f" dst=0x{self._dst:x}({dt}) src=0x{self._src:x}({st}) size={self._size}>") 1 ctx2cj

821  

822 def update( (empty)

823 self, 

824 *, 

825 dst: Buffer | int | None = None, (empty)

826 src: Buffer | int | None = None, (empty)

827 size: int | None = None, (empty)

828 dst_owner=None, (empty)

829 src_owner=None, (empty)

830 ) -> None: 

831 """Replace selected memcpy parameters. 

832  

833 Omitted parameters preserve their current values. ``dst_owner`` and 

834 ``src_owner`` may only accompany their corresponding raw addresses. 

835 Multidimensional, pitched, offset, and array-backed memcpy nodes are 

836 not supported. 

837  

838 With CUDA 12.2 through 13.1, the node's intended CUDA context must be 

839 current when this method is called. CUDA driver and ``cuda.bindings`` 

840 versions 13.2 and newer preserve the recorded context automatically. 

841  

842 .. warning:: 

843  

844 Use caution when a retained operand owner directly or indirectly 

845 owns a graph. Any reference cycle involving the owner and a graph 

846 that retains it cannot be broken by Python's cyclic garbage 

847 collector. Use a weak reference to break such cycles. 

848 """ 

849 cdef cydriver.CUdeviceptr c_dst = self._dst 16 ctx2b f c r s t /f:f;fm n o d e 6 a

850 cdef cydriver.CUdeviceptr c_src = self._src 16 ctx2b f c r s t /f:f;fm n o d e 6 a

851 cdef OpaqueHandle dst_attachment_owner 

852 cdef OpaqueHandle src_attachment_owner 

853 GN_check_valid(self) 16 ctx2b f c r s t /f:f;fm n o d e 6 a

854 cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) 13 ctx1bfcrstmnode6a

855 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 13 ctx1bfcrstmnode6a

856 cdef cydriver.CUcontext ctx = NULL 13 ctx1bfcrstmnode6a

857 cdef cydriver.CUgraphNodeParams params 

858 cdef cydriver.CUmemorytype c_dst_type 

859 cdef cydriver.CUmemorytype c_src_type 

860 cdef object queried 

861  

862 if dst is None and dst_owner is not None: 13 ctx1bfcrstmnode6a

863 raise ValueError("dst_owner requires dst") 

864 if src is None and src_owner is not None: 13 ctx1bfcrstmnode6a

865 raise ValueError("src_owner requires src") 

866 if dst is None and src is None and size is None: 13 ctx1bfcrstmnode6a

867 return 

868  

869 c_memset(&params, 0, sizeof(params)) 13 ctx1bfcrstmnode6a

870 params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMCPY 13 ctx1bfcrstmnode6a

871 with nogil: 13 ctx1bfcrstmnode6a

872 HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams( 13 ctx1bfcrstmnode6a

873 node, &params.memcpy.copyParams)) 

874 if _check_node_get_params(): 13 ctx1bfcrstmnode6a

875 queried = handle_return(driver.cuGraphNodeGetParams( 13 ctx1bfcrstmnode6a

876 <uintptr_t>node)) 13 ctx1bfcrstmnode6a

877 ctx = <cydriver.CUcontext><uintptr_t>int( 13 ctx1bfcrstmnode6a

878 queried.memcpy.copyCtx) 13 ctx1bfcrstmnode6a

879 else: 

880 with nogil: 

881 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) 

882 params.memcpy.copyCtx = ctx 13 ctx1bfcrstmnode6a

883  

884 if not _is_supported_memcpy_descriptor(&params.memcpy.copyParams): 13 ctx1bfcrstmnode6a

885 raise NotImplementedError( 1 ctx16

886 "updating multidimensional, pitched, offset, or array-backed " 

887 "memcpy nodes is not supported") 

888  

889 c_dst_type = params.memcpy.copyParams.dstMemoryType 12 ctx1bfcrstmnodea

890 c_src_type = params.memcpy.copyParams.srcMemoryType 12 ctx1bfcrstmnodea

891 if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: 12 ctx1bfcrstmnodea

892 c_dst = <cydriver.CUdeviceptr><uintptr_t>( 12 ctx1bfcrstmnodea

893 params.memcpy.copyParams.dstHost) 

894 elif c_dst_type == cydriver.CU_MEMORYTYPE_DEVICE: 

895 c_dst = params.memcpy.copyParams.dstDevice 

896 else: 

897 raise NotImplementedError( 

898 f"unsupported destination memory type: {int(c_dst_type)}") 

899 if c_src_type == cydriver.CU_MEMORYTYPE_HOST: 12 ctx1bfcrstmnodea

900 c_src = <cydriver.CUdeviceptr><uintptr_t>( 12 ctx1bfcrstmnodea

901 params.memcpy.copyParams.srcHost) 

902 elif c_src_type == cydriver.CU_MEMORYTYPE_DEVICE: 

903 c_src = params.memcpy.copyParams.srcDevice 

904 else: 

905 raise NotImplementedError( 

906 f"unsupported source memory type: {int(c_src_type)}") 

907  

908 HANDLE_RETURN(graph_get_attachment( 12 ctx1bfcrstmnodea

909 h_graph, node, 

910 &dst_attachment_owner, &src_attachment_owner)) 

911 if dst is not None: 12 ctx1bfcrstmnodea

912 dst_attachment_owner = _resolve_memcpy_operand( 2 ctx1be

913 dst, dst_owner, "dst", &c_dst) 

914 c_dst_type = _get_memcpy_memory_type(c_dst) 2 ctx1be

915 params.memcpy.copyParams.dstMemoryType = c_dst_type 2 ctx1be

916 params.memcpy.copyParams.dstHost = NULL 2 ctx1be

917 params.memcpy.copyParams.dstDevice = 0 2 ctx1be

918 params.memcpy.copyParams.dstArray = NULL 2 ctx1be

919 params.memcpy.copyParams.reserved1 = NULL 2 ctx1be

920 if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: 2 ctx1be

921 params.memcpy.copyParams.dstHost = <void*><uintptr_t>c_dst 1 ctx1b

922 else: 

923 params.memcpy.copyParams.dstDevice = c_dst 1 ctx1e

924 if src is not None: 12 ctx1bfcrstmnodea

925 src_attachment_owner = _resolve_memcpy_operand( 5 ctx1crstd

926 src, src_owner, "src", &c_src) 

927 c_src_type = _get_memcpy_memory_type(c_src) 2 ctx1cd

928 params.memcpy.copyParams.srcMemoryType = c_src_type 2 ctx1cd

929 params.memcpy.copyParams.srcHost = NULL 2 ctx1cd

930 params.memcpy.copyParams.srcDevice = 0 2 ctx1cd

931 params.memcpy.copyParams.srcArray = NULL 2 ctx1cd

932 params.memcpy.copyParams.reserved0 = NULL 2 ctx1cd

933 if c_src_type == cydriver.CU_MEMORYTYPE_HOST: 2 ctx1cd

934 params.memcpy.copyParams.srcHost = <void*><uintptr_t>c_src 1 ctx1c

935 else: 

936 params.memcpy.copyParams.srcDevice = c_src 1 ctx1d

937 if size is not None: 9 ctx1bfcmnodea

938 params.memcpy.copyParams.WidthInBytes = size 5 ctx1fmnoa

939  

940 _set_definition_node_params( 6 ctx1bfcdea

941 self._h_node, &params, 

942 dst_attachment_owner, src_attachment_owner, 

943 params.memcpy.copyCtx) 

944 self._dst = c_dst 6 ctx1bfcdea

945 self._src = c_src 6 ctx1bfcdea

946 self._size = params.memcpy.copyParams.WidthInBytes 6 ctx1bfcdea

947 self._dst_type = c_dst_type 6 ctx1bfcdea

948 self._src_type = c_src_type 6 ctx1bfcdea

949  

950 @property 

951 def dst(self) -> int: 

952 """The destination pointer.""" 

953 return self._dst 11 ctx2mkabb f c E F G m n o

954  

955 @property 

956 def src(self) -> int: 

957 """The source pointer.""" 

958 return self._src 11 ctx2mkabb f c E F G m n o

959  

960 @property 

961 def size(self) -> int: 

962 """The number of bytes copied.""" 

963 return self._size 11 ctx2mkabb f c E F G m n o

964  

965  

966cdef class ChildGraphNode(GraphNode): 

967 """A child graph node. 

968  

969 Properties 

970 ---------- 

971 child_graph : GraphDefinition 

972 The embedded graph definition (non-owning wrapper). 

973 """ 

974  

975 @staticmethod (empty)

976 cdef ChildGraphNode _create_with_params(GraphNodeHandle h_node, 

977 GraphHandle h_child_graph): 

978 """Create from known params (called by embed() builder).""" 

979 cdef ChildGraphNode n = ChildGraphNode.__new__(ChildGraphNode) 85 ctx2hcufvfwfxfyfzfAf? ~bB _i{ }f@ ` Hb| D _fK V =fReA 9 BfCfacDfPdQdodEfFfGfHfIfJfKfsbLfhbMfNfOfRf+ : SfTfUfVfbcWfSdTdpdXfYfZf0f1f2f3ftb4fib5f6f7f!f, ; #f$f%f'f(f)f*f+f,f-f.f

980 n._h_node = h_node 85 ctx2hcufvfwfxfyfzfAf? ~bB _i{ }f@ ` Hb| D _fK V =fReA 9 BfCfacDfPdQdodEfFfGfHfIfJfKfsbLfhbMfNfOfRf+ : SfTfUfVfbcWfSdTdpdXfYfZf0f1f2f3ftb4fib5f6f7f!f, ; #f$f%f'f(f)f*f+f,f-f.f

981 n._h_child_graph = h_child_graph 85 ctx2hcufvfwfxfyfzfAf? ~bB _i{ }f@ ` Hb| D _fK V =fReA 9 BfCfacDfPdQdodEfFfGfHfIfJfKfsbLfhbMfNfOfRf+ : SfTfUfVfbcWfSdTdpdXfYfZf0f1f2f3ftb4fib5f6f7f!f, ; #f$f%f'f(f)f*f+f,f-f.f

982 return n 85 ctx2hcufvfwfxfyfzfAf? ~bB _i{ }f@ ` Hb| D _fK V =fReA 9 BfCfacDfPdQdodEfFfGfHfIfJfKfsbLfhbMfNfOfRf+ : SfTfUfVfbcWfSdTdpdXfYfZf0f1f2f3ftb4fib5f6f7f!f, ; #f$f%f'f(f)f*f+f,f-f.f

983  

984 @staticmethod (empty)

985 cdef ChildGraphNode _create_from_driver(GraphNodeHandle h_node): 

986 """Create by fetching params from the driver (called by _create factory).""" 

987 cdef cydriver.CUgraphNode node = as_cu(h_node) 7 ctx1?B{@`|D

988 cdef cydriver.CUgraph child_graph = NULL 7 ctx1?B{@`|D

989 with nogil: 7 ctx1?B{@`|D

990 HANDLE_RETURN(cydriver.cuGraphChildGraphNodeGetGraph(node, &child_graph)) 7 ctx1?B{@`|D

991 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 7 ctx1?B{@`|D

992 cdef GraphHandle h_child = create_child_graph_handle( 7 ctx1?B{@`|D

993 child_graph, h_graph, node) 

994 return ChildGraphNode._create_with_params(h_node, h_child) 7 ctx1?B{@`|D

995  

996 def __repr__(self) -> str: 

997 return (f"<ChildGraphNode handle=0x{as_intptr(self._h_node):x}" 7 ctx2? B @ Hb_fK qk

998 f" child=0x{as_intptr(self._h_child_graph):x}>") 7 ctx2? B @ Hb_fK qk

999  

1000 def update(self, child: GraphDefinition) -> None: (empty)

1001 """Replace the embedded graph with a clone of ``child``. 

1002  

1003 ``child`` must belong to an independent graph hierarchy. 

1004 """ 

1005 GN_check_valid(self) 5 ctx2B D V Re9

1006 GD_check_valid(child) 4 ctx1BDV9

1007 cdef GraphHandle h_parent = graph_node_get_graph(self._h_node) 4 ctx1BDV9

1008 cdef GraphHandle h_replacement 

1009 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 4 ctx1BDV9

1010 cdef cydriver.CUgraphNodeParams params 

1011 cdef cydriver.CUresult commit_status 

1012 cdef PreparedChildGraphUpdate prepared 

1013  

1014 _require_graph_node_update_support() 4 ctx1BDV9

1015 c_memset(&params, 0, sizeof(params)) 4 ctx1BDV9

1016 params.type = cydriver.CU_GRAPH_NODE_TYPE_GRAPH 4 ctx1BDV9

1017 params.graph.graph = as_cu(child._h_graph) 4 ctx1BDV9

1018  

1019 HANDLE_RETURN(graph_prepare_child_graph_update( 4 ctx1BDV9

1020 h_parent, self._h_child_graph, node, 

1021 child._h_graph, &prepared)) 

1022 with nogil: 3 ctx1BDV

1023 HANDLE_RETURN(cydriver.cuGraphNodeSetParams( 3 ctx1BDV

1024 node, &params)) 

1025 try: 3 ctx1BDV

1026 commit_status = graph_commit_child_graph_update( 3 ctx1BDV

1027 prepared, &h_replacement) 

1028 finally: 

1029 if h_replacement: 3 ctx1BDV

1030 self._h_child_graph = h_replacement 3 ctx1BDV

1031 HANDLE_RETURN(commit_status) 3 ctx1BDV

1032  

1033 @property 

1034 def child_graph(self) -> GraphDefinition: 

1035 """The embedded graph definition (non-owning wrapper).""" 

1036 return GraphDefinition._from_handle(self._h_child_graph) 19 ctx2hcEdBk? ~bB _i{ @ ` Hb| D _fV =fReA 9

1037  

1038  

1039cdef class EventRecordNode(GraphNode): 

1040 """An event record node. 

1041  

1042 Properties 

1043 ---------- 

1044 event : Event 

1045 The event being recorded. 

1046 """ 

1047  

1048 @staticmethod (empty)

1049 cdef EventRecordNode _create_with_params(GraphNodeHandle h_node, 

1050 EventHandle h_event): 

1051 """Create from known params (called by record() builder).""" 

1052 cdef EventRecordNode n = EventRecordNode.__new__(EventRecordNode) 80 ctx2whAeCeEeGeIeKe`i)d{ixhyhzeX N ~ficI C yevddjejMefjPdgjhjijAdjjzhagkjljmjnjqdojpjPfqjcbzbrjsjtjujOevjSdwjxjyjCdzjAhbgAjBjCjDjsdEjFj8fGjfbCbHjIjJjKjLjMjNjOjPjQjRj

1053 n._h_node = h_node 80 ctx2whAeCeEeGeIeKe`i)d{ixhyhzeX N ~ficI C yevddjejMefjPdgjhjijAdjjzhagkjljmjnjqdojpjPfqjcbzbrjsjtjujOevjSdwjxjyjCdzjAhbgAjBjCjDjsdEjFj8fGjfbCbHjIjJjKjLjMjNjOjPjQjRj

1054 n._h_event = h_event 80 ctx2whAeCeEeGeIeKe`i)d{ixhyhzeX N ~ficI C yevddjejMefjPdgjhjijAdjjzhagkjljmjnjqdojpjPfqjcbzbrjsjtjujOevjSdwjxjyjCdzjAhbgAjBjCjDjsdEjFj8fGjfbCbHjIjJjKjLjMjNjOjPjQjRj

1055 return n 80 ctx2whAeCeEeGeIeKe`i)d{ixhyhzeX N ~ficI C yevddjejMefjPdgjhjijAdjjzhagkjljmjnjqdojpjPfqjcbzbrjsjtjujOevjSdwjxjyjCdzjAhbgAjBjCjDjsdEjFj8fGjfbCbHjIjJjKjLjMjNjOjPjQjRj

1056  

1057 @staticmethod (empty)

1058 cdef EventRecordNode _create_from_driver(GraphNodeHandle h_node): 

1059 """Create by fetching params from the driver (called by _create factory).""" 

1060 cdef cydriver.CUgraphNode node = as_cu(h_node) 

1061 cdef cydriver.CUevent event 

1062 with nogil: 

1063 HANDLE_RETURN(cydriver.cuGraphEventRecordNodeGetEvent(node, &event)) 

1064 cdef EventHandle h_event = create_event_handle_ref(event) 

1065 return EventRecordNode._create_with_params(h_node, h_event) 

1066  

1067 def __repr__(self) -> str: 

1068 return (f"<EventRecordNode handle=0x{as_intptr(self._h_node):x}" 1 ctx2rk

1069 f" event=0x{as_intptr(self._h_event):x}>") 1 ctx2rk

1070  

1071 def update(self, event: Event) -> None: (empty)

1072 """Replace the event recorded by this node.""" 

1073 GN_check_valid(self) 3 ctx2X icye

1074 Event_check_open(event) 2 ctx2X ye

1075 cdef OpaqueHandle event_owner = event._h_event 1 ctx1X

1076 cdef cydriver.CUgraphNodeParams params 

1077  

1078 c_memset(&params, 0, sizeof(params)) 1 ctx1X

1079 params.type = cydriver.CU_GRAPH_NODE_TYPE_EVENT_RECORD 1 ctx1X

1080 params.eventRecord.event = as_cu(event._h_event) 1 ctx1X

1081  

1082 _set_definition_node_params( 1 ctx1X

1083 self._h_node, &params, event_owner) 

1084 self._h_event = event._h_event 1 ctx1X

1085  

1086 @property 

1087 def event(self) -> Event: 

1088 """The event being recorded.""" 

1089 return Event._from_handle(self._h_event) 8 ctx2Ckcc`i)d{iX I ye

1090  

1091  

1092cdef class EventWaitNode(GraphNode): 

1093 """An event wait node. 

1094  

1095 Properties 

1096 ---------- 

1097 event : Event 

1098 The event being waited on. 

1099 """ 

1100  

1101 @staticmethod (empty)

1102 cdef EventWaitNode _create_with_params(GraphNodeHandle h_node, 

1103 EventHandle h_event): 

1104 """Create from known params (called by wait() builder).""" 

1105 cdef EventWaitNode n = EventWaitNode.__new__(EventWaitNode) 75 ctx2whBeDeFeHeJeLexhyh*d|iN cgjcC vdSjTjNeUjQdVjWjXjBdYjzhdgZj0j1j2jrd3j4jQf5jdbAb6j7j8j9jPe!jTd#j$j%jDd'jAheg(j)j*j+jtd,j-j9f.jgbDb/j:j;j=j?j@j[j]j^j_j`j

1106 n._h_node = h_node 75 ctx2whBeDeFeHeJeLexhyh*d|iN cgjcC vdSjTjNeUjQdVjWjXjBdYjzhdgZj0j1j2jrd3j4jQf5jdbAb6j7j8j9jPe!jTd#j$j%jDd'jAheg(j)j*j+jtd,j-j9f.jgbDb/j:j;j=j?j@j[j]j^j_j`j

1107 n._h_event = h_event 75 ctx2whBeDeFeHeJeLexhyh*d|iN cgjcC vdSjTjNeUjQdVjWjXjBdYjzhdgZj0j1j2jrd3j4jQf5jdbAb6j7j8j9jPe!jTd#j$j%jDd'jAheg(j)j*j+jtd,j-j9f.jgbDb/j:j;j=j?j@j[j]j^j_j`j

1108 return n 75 ctx2whBeDeFeHeJeLexhyh*d|iN cgjcC vdSjTjNeUjQdVjWjXjBdYjzhdgZj0j1j2jrd3j4jQf5jdbAb6j7j8j9jPe!jTd#j$j%jDd'jAheg(j)j*j+jtd,j-j9f.jgbDb/j:j;j=j?j@j[j]j^j_j`j

1109  

1110 @staticmethod (empty)

1111 cdef EventWaitNode _create_from_driver(GraphNodeHandle h_node): 

1112 """Create by fetching params from the driver (called by _create factory).""" 

1113 cdef cydriver.CUgraphNode node = as_cu(h_node) 

1114 cdef cydriver.CUevent event 

1115 with nogil: 

1116 HANDLE_RETURN(cydriver.cuGraphEventWaitNodeGetEvent(node, &event)) 

1117 cdef EventHandle h_event = create_event_handle_ref(event) 

1118 return EventWaitNode._create_with_params(h_node, h_event) 

1119  

1120 def __repr__(self) -> str: 

1121 return (f"<EventWaitNode handle=0x{as_intptr(self._h_node):x}" 1 ctx2sk

1122 f" event=0x{as_intptr(self._h_event):x}>") 1 ctx2sk

1123  

1124 def update(self, event: Event) -> None: (empty)

1125 """Replace the event waited on by this node.""" 

1126 GN_check_valid(self) 3 ctx2N jcvd

1127 Event_check_open(event) 2 ctx2N vd

1128 cdef OpaqueHandle event_owner = event._h_event 1 ctx1N

1129 cdef cydriver.CUgraphNodeParams params 

1130  

1131 c_memset(&params, 0, sizeof(params)) 1 ctx1N