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

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() 47 ctx1CELqW0O89mljcgdhiPZQRBJDMNvwxFGHyzS!*+KrefbATIa

101 if version < (12, 2, 0): 47 ctx1CELqW0O89mljcgdhiPZQRBJDMNvwxFGHyzS!*+KrefbATIa

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() 47 ctx1CELqW0O89mljcgdhiPZQRBJDMNvwxFGHyzS!*+KrefbATIa

107 if version < (12, 2, 0): 47 ctx1CELqW0O89mljcgdhiPZQRBJDMNvwxFGHyzS!*+KrefbATIa

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) 16 ctx10O89mljcgdhiefba

121 cdef cydriver.CUgraphNode node = as_cu(h_node) 16 ctx10O89mljcgdhiefba

122 if as_cu(h_graph) == NULL: 16 ctx10O89mljcgdhiefba

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

124 if node == NULL: 16 ctx10O89mljcgdhiefba

125 raise RuntimeError("GraphNode has been destroyed") 

126 _require_graph_node_update_support() 16 ctx10O89mljcgdhiefba

127 cdef cydriver.CUcontext previous_ctx = NULL 16 ctx10O89mljcgdhiefba

128 cdef bint restore_ctx = False 16 ctx10O89mljcgdhiefba

129 cdef PreparedAttachment prepared 

130  

131 HANDLE_RETURN(graph_prepare_attachment( 16 ctx10O89mljcgdhiefba

132 h_graph, owner0, owner1, &prepared)) 

133 if update_ctx != NULL: 17 ctx1k0O89mljcgdhiefba

134 with nogil: 9 ctx1cgdhiefba

135 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&previous_ctx)) 9 ctx1cgdhiefba

136 if previous_ctx != update_ctx: 9 ctx1cgdhiefba

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

138 restore_ctx = True 1 ctx1a

139 try: 16 ctx10O89mljcgdhiefba

140 with nogil: 16 ctx10O89mljcgdhiefba

141 HANDLE_RETURN(cydriver.cuGraphNodeSetParams(node, params)) 16 ctx10O89mljcgdhiefba

142 finally: 

143 if restore_ctx: 16 ctx10O89mljcgdhiefba

144 with nogil: 1 ctx1a

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

146 HANDLE_RETURN(graph_commit_attachment(prepared, node)) 16 ctx10O89mljcgdhiefba

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 ctx1LqPBJDMNvwxFGHyzSKrATI

156  

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

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

159 if graph_exec == NULL: 22 ctx1LqPBJDMNvwxFGHyzSKrATI

160 raise RuntimeError("Graph has been closed") 

161 if node == NULL: 22 ctx1LqPBJDMNvwxFGHyzSKrATI

162 raise RuntimeError("GraphNode has been destroyed") 

163  

164 cdef PreparedExecAttachment prepared 

165 HANDLE_RETURN(graph_prepare_exec_attachment( 22 ctx1LqPBJDMNvwxFGHyzSKrATI

166 h_exec, owner0, owner1, &prepared)) 

167  

168 cdef cydriver.CUresult status 

169 with nogil: 22 ctx1LqPBJDMNvwxFGHyzSKrATI

170 status = cydriver.cuGraphExecNodeSetParams( 22 ctx1LqPBJDMNvwxFGHyzSKrATI

171 graph_exec, node, params) 

172 if status == cydriver.CUDA_SUCCESS: 22 ctx1LqPBJDMNvwxFGHyzSKrATI

173 graph_commit_exec_attachment(prepared) 21 ctx1LqPBJDMNvwxFGHyzSKrTI

174 HANDLE_RETURN(status) 22 ctx1LqPBJDMNvwxFGHyzSKrATI

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 ctx1ZQR

181  

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

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

184 cdef unsigned int enabled 

185 if graph_exec == NULL: 3 ctx1ZQR

186 raise RuntimeError("Graph has been closed") 

187 if node == NULL: 3 ctx1ZQR

188 raise RuntimeError("GraphNode has been destroyed") 

189 with nogil: 3 ctx1ZQR

190 HANDLE_RETURN(cydriver.cuGraphNodeGetEnabled( 3 ctx1ZQR

191 graph_exec, node, &enabled)) 

192 return enabled != 0 3 ctx1ZQR

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 ctx1ZQR

200  

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

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

203 if graph_exec == NULL: 3 ctx1ZQR

204 raise RuntimeError("Graph has been closed") 

205 if node == NULL: 3 ctx1ZQR

206 raise RuntimeError("GraphNode has been destroyed") 

207 with nogil: 3 ctx1ZQR

208 HANDLE_RETURN(cydriver.cuGraphNodeSetEnabled( 3 ctx1ZQR

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: 29 ctx1X13452Y6.cgdhistu#$nopUVef7ba

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

216 _has_cuGraphNodeGetParams = ( 

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

218 ) 

219 _version_checked = True 2 ctx1XY

220 return _has_cuGraphNodeGetParams 29 ctx1X13452Y6.cgdhistu#$nopUVef7ba

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 ctx1mlj*+

229 c_memset(&cooperative, 0, sizeof(cooperative)) 5 ctx1mlj*+

230 with nogil: 5 ctx1mlj*+

231 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( 5 ctx1mlj*+

232 node, <cydriver.CUkernelNodeAttrID>( 

233 cydriver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION), 

234 &cluster)) 

235 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( 5 ctx1mlj*+

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 ctx1mlj*+

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

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 ctx1cgdstunopef7a

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

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

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

252 and params.srcXInBytes == 0 13 ctx1cgdstunopef7a

253 and params.srcY == 0 12 ctx1cgdstunopefa

254 and params.srcZ == 0 12 ctx1cgdstunopefa

255 and params.srcLOD == 0 12 ctx1cgdstunopefa

256 and params.srcPitch == 0 12 ctx1cgdstunopefa

257 and params.srcHeight == 0 12 ctx1cgdstunopefa

258 and params.dstXInBytes == 0 12 ctx1cgdstunopefa

259 and params.dstY == 0 12 ctx1cgdstunopefa

260 and params.dstZ == 0 12 ctx1cgdstunopefa

261 and params.dstLOD == 0 12 ctx1cgdstunopefa

262 and params.dstPitch == 0 12 ctx1cgdstunopefa

263 and params.dstHeight == 0 12 ctx1cgdstunopefa

264 and params.Height == 1 12 ctx1cgdstunopefa

265 and params.Depth == 1 12 ctx1cgdstunopefa

266 and params.reserved0 == NULL 12 ctx1cgdstunopefa

267 and params.reserved1 == NULL 12 ctx1cgdstunopefa

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 ctx2gkhk0e1eik% ' ( ) 2e3e4ejkkklk5eLb6ebbMb7e8e9e!e#eNb$eHbOb%emkPb'eQb(e)e*e+enk,e-eok.e|f}f~fagbgpkjjqkrkskcgtkukdcK ogpg/eRbkj:eSbTb;eUb=eVb?eWb@eXb[eubGdHdCdsd]e^epcYbIb_e`e{eZbcb|e0b}e1b] ~e2b, dbeb_ 3b4b5b6b/ af7bbf8bcf9bdf!b#bef$bff%bgf'bhf(bifvbIdJdDdtdjfkfqc)bJblfmfnf*bfbof+bpf,b^ qf-b- gbhb` .b/b:b;b: rf=bsf?btf@buf[bvf]bwf^bxf_byf`bzf{bAf|bBf}b

277 n._h_node = h_node 177 ctx2gkhk0e1eik% ' ( ) 2e3e4ejkkklk5eLb6ebbMb7e8e9e!e#eNb$eHbOb%emkPb'eQb(e)e*e+enk,e-eok.e|f}f~fagbgpkjjqkrkskcgtkukdcK ogpg/eRbkj:eSbTb;eUb=eVb?eWb@eXb[eubGdHdCdsd]e^epcYbIb_e`e{eZbcb|e0b}e1b] ~e2b, dbeb_ 3b4b5b6b/ af7bbf8bcf9bdf!b#bef$bff%bgf'bhf(bifvbIdJdDdtdjfkfqc)bJblfmfnf*bfbof+bpf,b^ qf-b- gbhb` .b/b:b;b: rf=bsf?btf@buf[bvf]bwf^bxf_byf`bzf{bAf|bBf}b

278 return n 177 ctx2gkhk0e1eik% ' ( ) 2e3e4ejkkklk5eLb6ebbMb7e8e9e!e#eNb$eHbOb%emkPb'eQb(e)e*e+enk,e-eok.e|f}f~fagbgpkjjqkrkskcgtkukdcK ogpg/eRbkj:eSbTb;eUb=eVb?eWb@eXb[eubGdHdCdsd]e^epcYbIb_e`e{eZbcb|e0b}e1b] ~e2b, dbeb_ 3b4b5b6b/ af7bbf8bcf9bdf!b#bef$bff%bgf'bhf(bifvbIdJdDdtdjfkfqc)bJblfmfnf*bfbof+bpf,b^ qf-b- gbhb` .b/b:b;b: rf=bsf?btf@buf[bvf]bwf^bxf_byf`bzf{bAf|bBf}b

279  

280 def __repr__(self) -> str: 

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

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) 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

307 n._h_node = h_node 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

308 n._grid = grid 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

309 n._block = block 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

310 n._shmem_size = shmem_size 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

311 n._h_kernel = h_kernel 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

312 return n 186 ctx20dMh1d2d3dCfNhOhPhQhRhShThKdDfLdEfMdFfNdGfOdHfPdIfQdUhRdEdSdTdecVhWhygHeXhYh{ |f}f~fagbg? q m l j Zh0h1hzgAgBg~bacZ rcv w x dc* dg+ r FdA 2hJf3hKf4hfcUdLf5hVdWdudMfNfOfPfQf6hRf7hSf8hubpcTf9hibUf!hVf#hWfXfYfbc!d$h%h] ~ 'h(hZf)h, ; 0f*h1f+h2f,h3f-hgcXd4f.hYdZdvd5f6f7f8f9f/h!f:h#f;hvbqc$f=hjb%f?h'f@h(f)f*fcc#d[h]h^ ab^h_h+f`h- = ,f{h-f|h.f}h/f~h:fai;fbi=fci?fdi@fei[ffi]fgi

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 ctx20d1d2d3dKdRdEdSdTdec{ ?

318 cdef cydriver.CUDA_KERNEL_NODE_PARAMS params 

319 with nogil: 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

320 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams(node, &params)) 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

321 cdef KernelHandle h_kernel = create_kernel_handle_ref(params.kern) 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

322 return KernelNode._create_with_params( 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

323 h_node, 

324 (params.gridDimX, params.gridDimY, params.gridDimZ), 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

325 (params.blockDimX, params.blockDimY, params.blockDimZ), 12 ctx20d1d2d3dKdRdEdSdTdec{ ?

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 ctx2q r wk

331 f" kernel=0x{as_intptr(self._h_kernel):x}>") 3 ctx2q r wk

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 ctx2m l j zgAgBg* + Fd

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 ctx2m l j * + Fd

359 cdef OpaqueHandle kernel_owner 

360 cdef OpaqueHandle args_owner 

361 cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) 6 ctx2m l j * + Fd

362 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 6 ctx2m l j * + Fd

363 cdef cydriver.CUgraphNodeParams params 

364  

365 if config is not None: 6 ctx2m l j * + Fd

366 c_config = config 2 ctx2l Fd

367 if (c_config.cluster is not None or 2 ctx2l Fd

368 c_config.is_cooperative): 2 ctx2l Fd

369 raise NotImplementedError( 1 ctx2Fd

370 "updating clustered or cooperative kernel nodes is not " 

371 "supported") 

372 _require_graph_node_update_support() 5 ctx1mlj*+

373 _reject_unsupported_kernel_node(node) 5 ctx1mlj*+

374 if kernel is not None: 5 ctx1mlj*+

375 if args is None: 2 ctx1j+

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

377 c_kernel = kernel 1 ctx1j

378 h_kernel = c_kernel._h_kernel 1 ctx1j

379 if args is not None: 4 ctx1mlj*

380 arg_holder = ParamHolder(args) 3 ctx1mj*

381  

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

383 params.type = cydriver.CU_GRAPH_NODE_TYPE_KERNEL 3 ctx1mlj

384 with nogil: 3 ctx1mlj

385 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams( 3 ctx1mlj

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

387 HANDLE_RETURN(graph_get_attachment( 3 ctx1mlj

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

389  

390 if config is not None: 3 ctx1mlj

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

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

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

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

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

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

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

398 if kernel is not None: 3 ctx1mlj

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

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

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

402 kernel_owner = h_kernel 1 ctx1j

403 if args is not None: 3 ctx1mlj

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

405 params.kernel.extra = NULL 2 ctx1mj

406 kernel_args = arg_holder.kernel_args 2 ctx1mj

407 if kernel_args is None: 2 ctx1mj

408 args_owner = OpaqueHandle() 1 ctx1j

409 else: 

410 args_owner = make_opaque_py(kernel_args) 1 ctx1m

411  

412 _set_definition_node_params( 3 ctx1mlj

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

414 self._grid = ( 3 ctx1mlj

415 params.kernel.gridDimX, 3 ctx1mlj

416 params.kernel.gridDimY, 3 ctx1mlj

417 params.kernel.gridDimZ, 3 ctx1mlj

418 ) 

419 self._block = ( 3 ctx1mlj

420 params.kernel.blockDimX, 3 ctx1mlj

421 params.kernel.blockDimY, 3 ctx1mlj

422 params.kernel.blockDimZ, 3 ctx1mlj

423 ) 

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

425 self._h_kernel = h_kernel 3 ctx1mlj

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 ctx2likb

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 ctx2likb

436  

437 @property 

438 def shmem_size(self) -> int: 

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

440 return self._shmem_size 2 ctx2likb

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 ctx2likbygHem l j v w x * dg+

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 ctx2likbm l j v w x * dg+

455 shmem_size=self._shmem_size) 11 ctx2likbm l j v w x * dg+

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) 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

481 n._h_node = h_node 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

482 n._dptr = dptr 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

483 n._bytesize = bytesize 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

484 n._device_id = device_id 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

485 n._memory_type = memory_type 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

486 n._peer_access = peer_access 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

487 return n 449 ctx2qgrg$dCgDgEgFg0eGg1eHgIg%d'd(d)d*d% ' ( ) wbxbybzbJgKgLg2e3e4eMgNg5eIeJe+dLdLbsctcucvcsbOgtbPg6ehcKeicLejc,dkbMdbbMblbwcmbxcnbycobzcQg7eRg8eSgTgUg9eVg!eWgXgYgZg#eMeNe-dNdNbAcBcCcDcEc0gFc1gGc$eHcOeIcPeJc.dKcOdHbObLcMcNcOcPcQcRcScTc2gUc3gVc%eWcQeXcReYc/dZcPdPb0c1c2c3c4c5c6c7c4g5g'eSeTe:dQdQb8c9c!c#c6g(e7g)e8g9g!g*e#g+e$g%g'g,e(g-e)g*g.esg+g;d=dAb4d,g/e?dRb$c-g:e@dSb%cfcUeVe[d5d.g/gUdTb'c:g;g=g;e]dUb(c?g=e^dVb)c@g?e_dWb*c[g@e`dXb+c[eubGdHdCdsd]e^epcYbIb_e`e]g{e{dZb,cibwdxdkc|d}dcbBb~dae^g|ebe0b-c_g}ece1b.cbc] ~ `g~ede2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?c{gafee7b@c|gbffe8b[c}gcfge9b]c~gdfhe!b^cgcWeXeie6dahbhXd#b_cchdhehefje$b`cfhffke%b{cghgfle'b|chhhfme(b}cifvbIdJdDdtdjfkfqc)bJblfmfihnfne*b~cjbydzdlcoepefbEbqerejhofse+badkhpfte,bbdcc^ ablhqfue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdmhrfve=bhdnhsfwe?bidohtfxe@bjdphufye[bkdqhvfze]bldrhwfAe^bmdshxfBe_bndthyfCe`boduhzfDe{bpdvhAfEe|bqdwhBfFe}brd

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 ctx2sbtbhcicjckbbblbmbnbobEcFcGcHcIcJcKcHbLcNcPcRcTcUcVcWcXcYcZc0c2c4c6c

493 cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS params 

494 with nogil: 34 ctx2sbtbhcicjckbbblbmbnbobEcFcGcHcIcJcKcHbLcNcPcRcTcUcVcWcXcYcZc0c2c4c6c

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

496  

497 cdef str memory_type 

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

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

500 memory_type = "host" 

501 else: 

502 memory_type = "device" 34 ctx2sbtbhcicjckbbblbmbnbobEcFcGcHcIcJcKcHbLcNcPcRcTcUcVcWcXcYcZc0c2c4c6c

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 ctx2sbtbhcicjckbbblbmbnbobEcFcGcHcIcJcKcHbLcNcPcRcTcUcVcWcXcYcZc0c2c4c6c

513 cdef size_t i 

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

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

516  

517 return AllocNode._create_with_params( 34 ctx2sbtbhcicjckbbblbmbnbobEcFcGcHcIcJcKcHbLcNcPcRcTcUcVcWcXcYcZc0c2c4c6c

518 h_node, params.dptr, params.bytesize, 

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

520  

521 def __repr__(self) -> str: 

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

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

524  

525 @property 

526 def dptr(self) -> int: 

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

528 return self._dptr 229 ctx2qgrg$d%d'd(d)d*d% ' ( ) wbxbybzbbjcj+dLbsctcucvcsbtb,dMbwcxcyczc-dNbAcBcCcDc.dObMcOcQcSc/dPb1c3c5c7c:dQb8c9c!c#csgAb?dRb$c@dSb%c[dTb'c]dUb(c^dVb)c_dWb*c`dXb+cCdYbIb{dZb,cibwdxdkc|d}dcbBb~daebe0b-cce1b.cbc] ~ de2b/c, dbeb_ 3b4b5b6b; CbDbpb:c;c/ =c?cee7b@cfe8b[cge9b]che!b^cie#b_cje$b`cke%b{cle'b|cme(b}cDd)bJbne*b~cjbydzdlcoepefbEbqerese+badte,bbdcc^ abue-bcd- gbhb` .b/b:b;b= FbGbqbdded: fdgdve=bhdwe?bidxe@bjdye[bkdze]bldAe^bmdBe_bndCe`bodDe{bpdEe|bqdFe}brd

529  

530 @property 

531 def bytesize(self) -> int: 

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

533 return self._bytesize 4 ctx2bjcjsbtb

534  

535 @property 

536 def device_id(self) -> int: 

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

538 return self._device_id 4 ctx2bjcjsbtb

539  

540 @property 

541 def memory_type(self) -> str: 

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

543 return self._memory_type 4 ctx2bjcjsbtb

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 ctx2bjcjsbtb

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) 80 ctx2$d%d'd(d)d*d% ' ( ) wbxbybzb+d,d-d.d/d:dAb?d@d[d]d^d_d`dCd{dibwdxdkc|d}dcbBb~daebecebcdeeefegeheiejekelemeDdnejbydzdlcoepefbEbqereseteccuevewexeyezeAeBeCeDeEeFe

565 n._h_node = h_node 80 ctx2$d%d'd(d)d*d% ' ( ) wbxbybzb+d,d-d.d/d:dAb?d@d[d]d^d_d`dCd{dibwdxdkc|d}dcbBb~daebecebcdeeefegeheiejekelemeDdnejbydzdlcoepefbEbqereseteccuevewexeyezeAeBeCeDeEeFe

566 n._dptr = dptr 80 ctx2$d%d'd(d)d*d% ' ( ) wbxbybzb+d,d-d.d/d:dAb?d@d[d]d^d_d`dCd{dibwdxdkc|d}dcbBb~daebecebcdeeefegeheiejekelemeDdnejbydzdlcoepefbEbqereseteccuevewexeyezeAeBeCeDeEeFe

567 return n 80 ctx2$d%d'd(d)d*d% ' ( ) wbxbybzb+d,d-d.d/d:dAb?d@d[d]d^d_d`dCd{dibwdxdkc|d}dcbBb~daebecebcdeeefegeheiejekelemeDdnejbydzdlcoepefbEbqereseteccuevewexeyezeAeBeCeDeEeFe

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) 1 ctx2Ab

573 cdef cydriver.CUdeviceptr dptr 

574 with nogil: 1 ctx2Ab

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

576 return FreeNode._create_with_params(h_node, dptr) 1 ctx2Ab

577  

578 def __repr__(self) -> str: 

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

580  

581 @property 

582 def dptr(self) -> int: 

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

584 return self._dptr 3 ctx2JkjcAb

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) 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

613 n._h_node = h_node 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

614 n._dptr = dptr 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

615 n._value = value 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

616 n._element_size = element_size 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

617 n._width = width 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

618 n._height = height 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

619 n._pitch = pitch 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

620 return n 110 ctx2% ' ( ) wbxbybzbsctcucvcwcxcyczcAcBcCcDcMcOcQcSc1c3c5c7c8c9c!c#ctgugvg? Yeh i # $ egfgR y z U V b Ada $c%c'c(c)c*c+cIb,cBb-c.c~ /c; CbDbpb:c;c/ =c?c@c[c]c^c_c`c{c|c}cJb~cEbadbdabcd= FbGbqbdded: fdgdhdidjdkdldmdndodpdqdrd

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 ctx2yk

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

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) 10 ctx2h i # $ egfgU V b a

665 cdef GraphHandle h_graph 

666 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 8 ctx1hi#$UVba

667 cdef cydriver.CUcontext ctx = NULL 8 ctx1hi#$UVba

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: 8 ctx1hi#$UVba

673 raise ValueError("dst_owner requires dst") 1 ctx1b

674 if (dst is None and value is None and width is None and 8 ctx1hi#$UVba

675 height is None and pitch is None): 1 ctx1b

676 return 1 ctx1b

677  

678 c_memset(&params, 0, sizeof(params)) 8 ctx1hi#$UVba

679 params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMSET 8 ctx1hi#$UVba

680 with nogil: 8 ctx1hi#$UVba

681 HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams( 8 ctx1hi#$UVba

682 node, &current)) 

683 if _check_node_get_params(): 8 ctx1hi#$UVba

684 queried = handle_return(driver.cuGraphNodeGetParams( 8 ctx1hi#$UVba

685 <uintptr_t>node)) 8 ctx1hi#$UVba

686 ctx = <cydriver.CUcontext><uintptr_t>int(queried.memset.ctx) 8 ctx1hi#$UVba

687 else: 

688 with nogil: 

689 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) 

690  

691 cdef cydriver.CUdeviceptr c_dst = current.dst 8 ctx1hi#$UVba

692 cdef unsigned int c_value = current.value 8 ctx1hi#$UVba

693 cdef unsigned int c_element_size = current.elementSize 8 ctx1hi#$UVba

694 cdef size_t c_width = current.width 8 ctx1hi#$UVba

695 cdef size_t c_height = current.height 8 ctx1hi#$UVba

696 cdef size_t c_pitch = current.pitch 8 ctx1hi#$UVba

697  

698 if dst is None: 8 ctx1hi#$UVba

699 h_graph = graph_node_get_graph(self._h_node) 5 ctx1iUVba

700 HANDLE_RETURN(graph_get_attachment( 5 ctx1iUVba

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: 6 ctx1hiUVba

708 c_value, c_element_size = _parse_fill_value(value) 5 ctx1hiUVa

709 if width is not None: 4 ctx1hiba

710 c_width = width 1 ctx1b

711 if height is not None: 4 ctx1hiba

712 c_height = height 1 ctx1b

713 if pitch is not None: 4 ctx1hiba

714 c_pitch = pitch 1 ctx1b

715  

716 params.memset.dst = c_dst 4 ctx1hiba

717 params.memset.value = c_value 4 ctx1hiba

718 params.memset.elementSize = c_element_size 4 ctx1hiba

719 params.memset.width = c_width 4 ctx1hiba

720 params.memset.height = c_height 4 ctx1hiba

721 params.memset.pitch = c_pitch 4 ctx1hiba

722 params.memset.ctx = ctx 4 ctx1hiba

723  

724 _set_definition_node_params( 4 ctx1hiba

725 self._h_node, &params, dst_attachment_owner, 

726 OpaqueHandle(), params.memset.ctx) 

727 self._dptr = c_dst 4 ctx1hiba

728 self._value = c_value 4 ctx1hiba

729 self._element_size = c_element_size 4 ctx1hiba

730 self._width = c_width 4 ctx1hiba

731 self._height = c_height 4 ctx1hiba

732 self._pitch = c_pitch 4 ctx1hiba

733  

734 @property 

735 def dptr(self) -> int: 

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

737 return self._dptr 15 ctx2minioipilbmbnbobYeh i y z U V

738  

739 @property 

740 def value(self) -> int: 

741 """The fill value.""" 

742 return self._value 16 ctx2minioipilbmbnbobYeh i y z U V b

743  

744 @property 

745 def element_size(self) -> int: 

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

747 return self._element_size 14 ctx2minioipilbmbnbobh i y z U V

748  

749 @property 

750 def width(self) -> int: 

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

752 return self._width 16 ctx2minioipilbmbnbobYeh i y z U V b

753  

754 @property 

755 def height(self) -> int: 

756 """Number of rows.""" 

757 return self._height 15 ctx2minioipilbmbnbobh i y z U V b

758  

759 @property 

760 def pitch(self) -> int: 

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

762 return self._pitch 15 ctx2minioipilbmbnbobh i y z U V b

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) 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

785 n._h_node = h_node 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

786 n._dst = dst 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

787 n._src = src 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

788 n._size = size 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

789 n._dst_type = dst_type 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

790 n._src_type = src_type 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .b/b:b;b: =b?b@b[b]b^b_b`b{b|b}b

791 return n 101 ctx2% ' ( ) LbMbNbObPbQbxhyhrb7dzhAhBhChDhEhc g d s t u ^f_f`fQ F G H n o p e f 7 b Ada RbSbTbUbVbWbXbYbZbcb0b1b] 2b, dbeb_ 3b4b5b6b/ 7b8b9b!b#b$b%b'b(b)b*bfb+b,b^ -b- gbhb` .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) 1 ctx2rb

797 cdef cydriver.CUDA_MEMCPY3D params 

798 with nogil: 1 ctx2rb

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

800  

801 cdef cydriver.CUdeviceptr dst 

802 cdef cydriver.CUdeviceptr src 

803 if params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST: 1 ctx2rb

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

805 else: 

806 dst = params.dstDevice 

807 if params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST: 1 ctx2rb

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

809 else: 

810 src = params.srcDevice 

811  

812 return MemcpyNode._create_with_params( 1 ctx2rb

813 h_node, dst, src, params.WidthInBytes, 

814 params.dstMemoryType, params.srcMemoryType) 1 ctx2rb

815  

816 def __repr__(self) -> str: 

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

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

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

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

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 17 ctx2c g d s t u ^f_f`fn o p e f 7 b a

850 cdef cydriver.CUdeviceptr c_src = self._src 17 ctx2c g d s t u ^f_f`fn o p e f 7 b a

851 cdef OpaqueHandle dst_attachment_owner 

852 cdef OpaqueHandle src_attachment_owner 

853 GN_check_valid(self) 17 ctx2c g d s t u ^f_f`fn o p e f 7 b a

854 cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) 14 ctx1cgdstunopef7ba

855 cdef cydriver.CUgraphNode node = as_cu(self._h_node) 14 ctx1cgdstunopef7ba

856 cdef cydriver.CUcontext ctx = NULL 14 ctx1cgdstunopef7ba

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: 14 ctx1cgdstunopef7ba

863 raise ValueError("dst_owner requires dst") 1 ctx1b

864 if src is None and src_owner is not None: 14 ctx1cgdstunopef7ba

865 raise ValueError("src_owner requires src") 1 ctx1b

866 if dst is None and src is None and size is None: 14 ctx1cgdstunopef7ba

867 return 1 ctx1b

868  

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

870 params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMCPY 13 ctx1cgdstunopef7a

871 with nogil: 13 ctx1cgdstunopef7a

872 HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams( 13 ctx1cgdstunopef7a

873 node, &params.memcpy.copyParams)) 

874 if _check_node_get_params(): 13 ctx1cgdstunopef7a

875 queried = handle_return(driver.cuGraphNodeGetParams( 13 ctx1cgdstunopef7a

876 <uintptr_t>node)) 13 ctx1cgdstunopef7a

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

878 queried.memcpy.copyCtx) 13 ctx1cgdstunopef7a

879 else: 

880 with nogil: 

881 HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) 

882 params.memcpy.copyCtx = ctx 13 ctx1cgdstunopef7a

883  

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

885 raise NotImplementedError( 1 ctx17

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

887 "memcpy nodes is not supported") 

888  

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

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

891 if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: 12 ctx1cgdstunopefa

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

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 ctx1cgdstunopefa

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

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 ctx1cgdstunopefa

909 h_graph, node, 

910 &dst_attachment_owner, &src_attachment_owner)) 

911 if dst is not None: 12 ctx1cgdstunopefa

912 dst_attachment_owner = _resolve_memcpy_operand( 2 ctx1cf

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

914 c_dst_type = _get_memcpy_memory_type(c_dst) 2 ctx1cf

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

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

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

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

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

920 if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: 2 ctx1cf

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

922 else: 

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

924 if src is not None: 12 ctx1cgdstunopefa

925 src_attachment_owner = _resolve_memcpy_operand( 5 ctx1dstue

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

927 c_src_type = _get_memcpy_memory_type(c_src) 2 ctx1de

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

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

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

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

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

933 if c_src_type == cydriver.CU_MEMORYTYPE_HOST: 2 ctx1de

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

935 else: 

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

937 if size is not None: 9 ctx1cgdnopefa

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

939  

940 _set_definition_node_params( 6 ctx1cgdefa

941 self._h_node, &params, 

942 dst_attachment_owner, src_attachment_owner, 

943 params.memcpy.copyCtx) 

944 self._dst = c_dst 6 ctx1cgdefa

945 self._src = c_src 6 ctx1cgdefa

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

947 self._dst_type = c_dst_type 6 ctx1cgdefa

948 self._src_type = c_src_type 6 ctx1cgdefa

949  

950 @property 

951 def dst(self) -> int: 

952 """The destination pointer.""" 

953 return self._dst 13 ctx2vkbbrbc g d F G H n o p b

954  

955 @property 

956 def src(self) -> int: 

957 """The source pointer.""" 

958 return self._src 13 ctx2vkbbrbc g d F G H n o p b

959  

960 @property 

961 def size(self) -> int: 

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

963 return self._size 13 ctx2vkbbrbc g d F G H n o p b

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 ctx2mcCfDfEfFfGfHfIf@ ecC dj| gg[ { Kb} E cgL W {fZeB ! JfKffcLfVdWdudMfNfOfPfQfRfSfubTfibUfVfWfZf, ; 0f1f2f3fgc4fYdZdvd5f6f7f8f9f!f#fvb$fjb%f'f(f+f- = ,f-f.f/f:f;f=f?f@f[f]f

980 n._h_node = h_node 85 ctx2mcCfDfEfFfGfHfIf@ ecC dj| gg[ { Kb} E cgL W {fZeB ! JfKffcLfVdWdudMfNfOfPfQfRfSfubTfibUfVfWfZf, ; 0f1f2f3fgc4fYdZdvd5f6f7f8f9f!f#fvb$fjb%f'f(f+f- = ,f-f.f/f:f;f=f?f@f[f]f

981 n._h_child_graph = h_child_graph 85 ctx2mcCfDfEfFfGfHfIf@ ecC dj| gg[ { Kb} E cgL W {fZeB ! JfKffcLfVdWdudMfNfOfPfQfRfSfubTfibUfVfWfZf, ; 0f1f2f3fgc4fYdZdvd5f6f7f8f9f!f#fvb$fjb%f'f(f+f- = ,f-f.f/f:f;f=f?f@f[f]f

982 return n 85 ctx2mcCfDfEfFfGfHfIf@ ecC dj| gg[ { Kb} E cgL W {fZeB ! JfKffcLfVdWdudMfNfOfPfQfRfSfubTfibUfVfWfZf, ; 0f1f2f3fgc4fYdZdvd5f6f7f8f9f!f#fvb$fjb%f'f(f+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@C|[{}E

988 cdef cydriver.CUgraph child_graph = NULL 7 ctx1@C|[{}E

989 with nogil: 7 ctx1@C|[{}E

990 HANDLE_RETURN(cydriver.cuGraphChildGraphNodeGetGraph(node, &child_graph)) 7 ctx1@C|[{}E

991 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 7 ctx1@C|[{}E

992 cdef GraphHandle h_child = create_child_graph_handle( 7 ctx1@C|[{}E

993 child_graph, h_graph, node) 

994 return ChildGraphNode._create_with_params(h_node, h_child) 7 ctx1@C|[{}E

995  

996 def __repr__(self) -> str: 

997 return (f"<ChildGraphNode handle=0x{as_intptr(self._h_node):x}" 7 ctx2@ C [ KbcgL zk

998 f" child=0x{as_intptr(self._h_child_graph):x}>") 7 ctx2@ C [ KbcgL zk

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 ctx2C E W Ze!

1006 GD_check_valid(child) 4 ctx1CEW!

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

1008 cdef GraphHandle h_replacement 

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

1010 cdef cydriver.CUgraphNodeParams params 

1011 cdef cydriver.CUresult commit_status 

1012 cdef PreparedChildGraphUpdate prepared 

1013  

1014 _require_graph_node_update_support() 4 ctx1CEW!

1015 c_memset(&params, 0, sizeof(params)) 4 ctx1CEW!

1016 params.type = cydriver.CU_GRAPH_NODE_TYPE_GRAPH 4 ctx1CEW!

1017 params.graph.graph = as_cu(child._h_graph) 4 ctx1CEW!

1018  

1019 HANDLE_RETURN(graph_prepare_child_graph_update( 4 ctx1CEW!

1020 h_parent, self._h_child_graph, node, 

1021 child._h_graph, &prepared)) 

1022 with nogil: 3 ctx1CEW

1023 HANDLE_RETURN(cydriver.cuGraphNodeSetParams( 3 ctx1CEW

1024 node, &params)) 

1025 try: 3 ctx1CEW

1026 commit_status = graph_commit_child_graph_update( 3 ctx1CEW

1027 prepared, &h_replacement) 

1028 finally: 

1029 if h_replacement: 3 ctx1CEW

1030 self._h_child_graph = h_replacement 3 ctx1CEW

1031 HANDLE_RETURN(commit_status) 3 ctx1CEW

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 ctx2mcKdKk@ ecC dj| [ { Kb} E cgW {fZeB !

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) 84 ctx2FhIeKeMeOeQeSeej;dfjGhHh8d9dAbrbHe0 O hgncJ D GeBdmjnjUeojVdpjqjrjGdsjIhigtjujvjwjwdxjyjXfzjdbCbAjBjCjDjWeEjYdFjGjHjIdIjJhjgJjKjLjMjydNjOj)fPjgbFbQjRjSjTjUjVjWjXjYjZj0j

1053 n._h_node = h_node 84 ctx2FhIeKeMeOeQeSeej;dfjGhHh8d9dAbrbHe0 O hgncJ D GeBdmjnjUeojVdpjqjrjGdsjIhigtjujvjwjwdxjyjXfzjdbCbAjBjCjDjWeEjYdFjGjHjIdIjJhjgJjKjLjMjydNjOj)fPjgbFbQjRjSjTjUjVjWjXjYjZj0j

1054 n._h_event = h_event 84 ctx2FhIeKeMeOeQeSeej;dfjGhHh8d9dAbrbHe0 O hgncJ D GeBdmjnjUeojVdpjqjrjGdsjIhigtjujvjwjwdxjyjXfzjdbCbAjBjCjDjWeEjYdFjGjHjIdIjJhjgJjKjLjMjydNjOj)fPjgbFbQjRjSjTjUjVjWjXjYjZj0j

1055 return n 84 ctx2FhIeKeMeOeQeSeej;dfjGhHh8d9dAbrbHe0 O hgncJ D GeBdmjnjUeojVdpjqjrjGdsjIhigtjujvjwjwdxjyjXfzjdbCbAjBjCjDjWeEjYdFjGjHjIdIjJhjgJjKjLjMjydNjOj)fPjgbFbQjRjSjTjUjVjWjXjYjZj0j

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) 1 ctx28d

1061 cdef cydriver.CUevent event 

1062 with nogil: 1 ctx28d

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

1064 cdef EventHandle h_event = create_event_handle_ref(event) 1 ctx28d

1065 return EventRecordNode._create_with_params(h_node, h_event) 1 ctx28d

1066  

1067 def __repr__(self) -> str: 

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

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

1070  

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

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

1073 GN_check_valid(self) 3 ctx20 ncGe

1074 Event_check_open(event) 2 ctx20 Ge

1075 cdef OpaqueHandle event_owner = event._h_event 1 ctx10

1076 cdef cydriver.CUgraphNodeParams params 

1077  

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

1079 params.type = cydriver.CU_GRAPH_NODE_TYPE_EVENT_RECORD 1 ctx10

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

1081  

1082 _set_definition_node_params( 1 ctx10

1083 self._h_node, &params, event_owner) 

1084 self._h_event = event._h_event 1 ctx10

1085  

1086 @property 

1087 def event(self) -> Event: 

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

1089 return Event._from_handle(self._h_event) 9 ctx2Lkhcej;dfj8d0 J Ge

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) 77 ctx2FhJeLeNePeReTeGhHh=dgj8d9dO kgocD Bd1j2jVe3jWd4j5j6jHd7jIhlg8j9j!j#jxd$j%jYf'jebDb(j)j*j+jXe,jZd-j.j/jJd:jJhmg;j=j?j@jzd[j]j*f^jhbGb_j`j{j|j}j~jakbkckdkek

1106 n._h_node = h_node 77 ctx2FhJeLeNePeReTeGhHh=dgj8d9dO kgocD Bd1j2jVe3jWd4j5j6jHd7jIhlg8j9j!j#jxd$j%jYf'jebDb(j)j*j+jXe,jZd-j.j/jJd:jJhmg;j=j?j@jzd[j]j*f^jhbGb_j`j{j|j}j~jakbkckdkek

1107 n._h_event = h_event 77 ctx2FhJeLeNePeReTeGhHh=dgj8d9dO kgocD Bd1j2jVe3jWd4j5j6jHd7jIhlg8j9j!j#jxd$j%jYf'jebDb(j)j*j+jXe,jZd-j.j/jJd:jJhmg;j=j?j@jzd[j]j*f^jhbGb_j`j{j|j}j~jakbkckdkek

1108 return n 77 ctx2FhJeLeNePeReTeGhHh=dgj8d9dO kgocD Bd1j2jVe3jWd4j5j6jHd7jIhlg8j9j!j#jxd$j%jYf'jebDb(j)j*j+jXe,jZd-j.j/jJd:jJhmg;j=j?j@jzd[j]j*f^jhbGb_j`j{j|j}j~jakbkckdkek

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) 1 ctx29d

1114 cdef cydriver.CUevent event 

1115 with nogil: 1 ctx29d

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

1117 cdef EventHandle h_event = create_event_handle_ref(event) 1 ctx29d

1118 return EventWaitNode._create_with_params(h_node, h_event) 1 ctx29d