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

265 statements  

« prev     ^ index     » next       coverage.py v7.13.5, created at 2026-04-29 01:27 +0000

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

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 

11  

12from cuda.bindings cimport cydriver 

13  

14from cuda.core._event cimport Event 

15from cuda.core._launch_config cimport LaunchConfig 

16from cuda.core._module cimport Kernel 

17from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition 

18from cuda.core.graph._graph_node cimport GraphNode 

19from cuda.core._resource_handles cimport ( 

20 EventHandle, 

21 GraphHandle, 

22 KernelHandle, 

23 GraphNodeHandle, 

24 as_cu, 

25 as_intptr, 

26 create_event_handle_ref, 

27 create_graph_handle_ref, 

28 create_kernel_handle_ref, 

29 graph_node_get_graph, 

30) 

31from cuda.core._utils.cuda_utils cimport HANDLE_RETURN 

32  

33from cuda.core.graph._utils cimport _is_py_host_trampoline 

34  

35from cuda.core._utils.cuda_utils import driver, handle_return 

36  

37  

38cdef bint _has_cuGraphNodeGetParams = False 

39cdef bint _version_checked = False 

40  

41cdef bint _check_node_get_params(): 

42 global _has_cuGraphNodeGetParams, _version_checked 

43 if not _version_checked: 28c

44 from cuda.core._utils.version import driver_version 28c

45 _has_cuGraphNodeGetParams = driver_version() >= (13, 2, 0) 28c

46 _version_checked = True 28c

47 return _has_cuGraphNodeGetParams 2l 8c

48  

49  

50cdef class EmptyNode(GraphNode): 

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

52  

53 @staticmethod 

54 cdef EmptyNode _create_impl(GraphNodeHandle h_node): 

55 cdef EmptyNode n = EmptyNode.__new__(EmptyNode) 2YdZdGia b c d 0d1d2d3d1 4dv 2 5d6d7d8d9d3 !dY 4 #dHi5 $d6 %d'd(d)dIi*d+dJi,d?e@e[e]e^eKiOhLiMiNiOi-d7 .d8 9 /d! :d# ;d$ =d% ?dM LcMcIcAc@d[dzb' Z ]d^d_d( w `d) {d* m |d+ e x y q , - . / g }d: ~d; ae= be? @ ce[ de] ee^ fe_ geN NcOcJcBcheieAb` 0 jekele{ z me| ne} n oe~ f A B r abbbcbdbh peebqefbregbFdC sehbteibuejbvekbwelbxembyenb

56 n._h_node = h_node 2YdZdGia b c d 0d1d2d3d1 4dv 2 5d6d7d8d9d3 !dY 4 #dHi5 $d6 %d'd(d)dIi*d+dJi,d?e@e[e]e^eKiOhLiMiNiOi-d7 .d8 9 /d! :d# ;d$ =d% ?dM LcMcIcAc@d[dzb' Z ]d^d_d( w `d) {d* m |d+ e x y q , - . / g }d: ~d; ae= be? @ ce[ de] ee^ fe_ geN NcOcJcBcheieAb` 0 jekele{ z me| ne} n oe~ f A B r abbbcbdbh peebqefbregbFdC sehbteibuejbvekbwelbxembyenb

57 return n 2YdZdGia b c d 0d1d2d3d1 4dv 2 5d6d7d8d9d3 !dY 4 #dHi5 $d6 %d'd(d)dIi*d+dJi,d?e@e[e]e^eKiOhLiMiNiOi-d7 .d8 9 /d! :d# ;d$ =d% ?dM LcMcIcAc@d[dzb' Z ]d^d_d( w `d) {d* m |d+ e x y q , - . / g }d: ~d; ae= be? @ ce[ de] ee^ fe_ geN NcOcJcBcheieAb` 0 jekele{ z me| ne} n oe~ f A B r abbbcbdbh peebqefbregbFdC sehbteibuejbvekbwelbxembyenb

58  

59 def __repr__(self) -> str: 

60 return f"<EmptyNode handle=0x{as_intptr(self._h_node):x}>" 2OhFd

61  

62  

63cdef class KernelNode(GraphNode): 

64 """A kernel launch node. 

65  

66 Properties 

67 ---------- 

68 grid : tuple of int 

69 Grid dimensions (gridDimX, gridDimY, gridDimZ). 

70 block : tuple of int 

71 Block dimensions (blockDimX, blockDimY, blockDimZ). 

72 shmem_size : int 

73 Dynamic shared memory size in bytes. 

74 kernel : Kernel 

75 The kernel object for this launch node. 

76 config : LaunchConfig 

77 A LaunchConfig reconstructed from this node's parameters. 

78 """ 

79  

80 @staticmethod 

81 cdef KernelNode _create_with_params(GraphNodeHandle h_node, 

82 tuple grid, tuple block, unsigned int shmem_size, 

83 KernelHandle h_kernel): 

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

85 cdef KernelNode n = KernelNode.__new__(KernelNode) 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

86 n._h_node = h_node 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

87 n._grid = grid 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

88 n._block = block 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

89 n._shmem_size = shmem_size 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

90 n._h_kernel = h_kernel 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

91 return n 2zegghgigjgkglgmgPcAeQcBeRcCeScDeTcEeUcFeVcngWcKcXcYcrbgfGdogpgs ?e@e[e]e^ek qgGergHesgsbZcIetg0c1cCcJeKeLeMeNeugOevgPewgM zbQexgD ReygSezgTeUeVeob9cAgBgm t CgDgWeEge i XeFgYeGgZeHg0eIgtb2c1eJg3c4cDc2e3e4e5e6eKg7eLg8eMgN Ab9eNgE !eOg#ePg$e%e'epb!cQgRgn u SgTg(eUgf j )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

92  

93 @staticmethod 

94 cdef KernelNode _create_from_driver(GraphNodeHandle h_node): 

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

96 cdef cydriver.CUgraphNode node = as_cu(h_node) 2PcWcKcXcYcrbs k

97 cdef cydriver.CUDA_KERNEL_NODE_PARAMS params 

98 with nogil: 2PcWcKcXcYcrbs k

99 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams(node, &params)) 2PcWcKcXcYcrbs k

100 cdef KernelHandle h_kernel = create_kernel_handle_ref(params.kern) 2PcWcKcXcYcrbs k

101 return KernelNode._create_with_params( 2PcWcKcXcYcrbs k

102 h_node, 

103 (params.gridDimX, params.gridDimY, params.gridDimZ), 2PcWcKcXcYcrbs k

104 (params.blockDimX, params.blockDimY, params.blockDimZ), 2PcWcKcXcYcrbs k

105 params.sharedMemBytes, 

106 h_kernel) 

107  

108 def __repr__(self) -> str: 

109 return (f"<KernelNode handle=0x{as_intptr(self._h_node):x}" 2af

110 f" kernel=0x{as_intptr(self._h_kernel):x}>") 2af

111  

112 @property 

113 def grid(self) -> tuple: 

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

115 return self._grid 2l 6gF

116  

117 @property 

118 def block(self) -> tuple: 

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

120 return self._block 26gF

121  

122 @property 

123 def shmem_size(self) -> int: 

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

125 return self._shmem_size 26gF

126  

127 @property 

128 def kernel(self) -> Kernel: 

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

130 return Kernel._from_handle(self._h_kernel) 26gF gfGd

131  

132 @property 

133 def config(self) -> LaunchConfig: 

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

135  

136 Note: cluster dimensions and cooperative_launch are not preserved 

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

138 """ 

139 return LaunchConfig(grid=self._grid, block=self._block, 26gF

140 shmem_size=self._shmem_size) 26gF

141  

142  

143cdef class AllocNode(GraphNode): 

144 """A memory allocation node. 

145  

146 Properties 

147 ---------- 

148 dptr : int 

149 The device pointer for the allocation. 

150 bytesize : int 

151 The number of bytes allocated. 

152 device_id : int 

153 The device on which the allocation was made. 

154 memory_type : str 

155 The type of memory allocated (``"device"``, ``"host"``, or ``"managed"``). 

156 peer_access : tuple of int 

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

158 options : GraphAllocOptions 

159 A GraphAllocOptions reconstructed from this node's parameters. 

160 """ 

161  

162 @staticmethod 

163 cdef AllocNode _create_with_params(GraphNodeHandle h_node, 

164 cydriver.CUdeviceptr dptr, size_t bytesize, 

165 int device_id, str memory_type, tuple peer_access): 

166 """Create from known params (called by alloc() builder).""" 

167 cdef AllocNode n = AllocNode.__new__(AllocNode) 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

168 n._h_node = h_node 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

169 n._dptr = dptr 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

170 n._bytesize = bytesize 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

171 n._device_id = device_id 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

172 n._memory_type = memory_type 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

173 n._peer_access = peer_access 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

174 return n 2bfcf$chfifjfkfYdlfZdmfnf%c'c(c)c*ca b c d O P Q R ofpfqf0d1d2drfsf3dHdId+cQc1 BbCbDbEbo tfp uf4dubJdvbKdwb,cF Rcv 2 G FbH GbI HbJ Ibvf5dwf6dxfyfzf7dAf8dBfCfDfEf9dLdMd-cSc3 JbKbLbMbNbFfObGfPb!dQbNdRbOdSb.cTbTcY 4 UbVbWbXbYbZb0b1b2bHf3bIf4b#d5bPd6bQd7b/c8bUc5 9b!b#b$b%b'b(b)bJfKf$dRdSd:cVc6 *b+b,b-bLf%dMf'dNfOfPf(dQf)dRfSfTf*dUf+dVfWf,ddfXf;c=cYf-d?c7 .bZf.d@c8 /bsbTdUd[c5c0f1fZc9 :b2f3f4f/d]c! ;b5f:d^c# =b6f;d_c$ ?b7f=d`c% @b?dM LcMcIcAc@d[dzb' Z ]d^d8f_d{c( [bD EcFcxb|c}cw S ~cad9f`dbd) ]b!f{dcd* ^bobm t #f|ddd+ _be x y q , - . / i T U K `b{bg |b}b$f}ded: ~b%f~dfd; ac'faegd= bc(fbehd? cctbVdWdid6c)f*f2c@ dc+f,f-fcejd[ ec.fdekd] fc/feeld^ gc:ffemd_ hcgeN NcOcJcBcheieAb` 0 jeke;flend{ icE GcHcybodpdz V qdrd=fmesd| jc?fnetd} kcpbn u @foeud~ lcf A B r abbbcbdbj W X L mcnch ocpc[fpevdebqc]fqewdfbrc^frexdgbsc_eFd7cC qb_fseydhbtc`ftezdibuc{fueAdjbvc|fveBdkbwc}fweCdlbxc~fxeDdmbycagyeEdnbzc

175  

176 @staticmethod 

177 cdef AllocNode _create_from_driver(GraphNodeHandle h_node): 

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

179 cdef cydriver.CUgraphNode node = as_cu(h_node) 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

180 cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS params 

181 with nogil: 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

182 HANDLE_RETURN(cydriver.cuGraphMemAllocNodeGetParams(node, &params)) 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

183  

184 cdef str memory_type 

185 if params.poolProps.allocType == cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_PINNED: 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

186 if params.poolProps.location.type == cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST: 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

187 memory_type = "host" 

188 else: 

189 memory_type = "device" 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

190 else: 

191 IF CUDA_CORE_BUILD_MAJOR >= 13: 

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

193 memory_type = "managed" 

194 else: 

195 memory_type = "device" 

196 ELSE: 

197 memory_type = "device" 

198  

199 cdef list peer_ids = [] 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

200 cdef size_t i 

201 for i in range(params.accessDescCount): 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

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

203  

204 return AllocNode._create_with_params( 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

205 h_node, params.dptr, params.bytesize, 

206 <int>params.poolProps.location.id, memory_type, tuple(peer_ids)) 2o p ubvbwbF v G H I J NbObPbQbRbSbTbY UbWbYb0b2b3b4b5b6b7b8b9b#b%b(b

207  

208 def __repr__(self) -> str: 

209 return (f"<AllocNode handle=0x{as_intptr(self._h_node):x}" 2_e

210 f" dptr=0x{self._dptr:x} size={self._bytesize}>") 2_e

211  

212 @property 

213 def dptr(self) -> int: 

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

215 return self._dptr 2bfcf$c%c'c(c)c*ca b c d O P Q R efff+c1 BbCbDbEbo p ,c2 FbGbHbIb-c3 JbKbLbMb.c4 VbXbZb1b/c5 !b$b'b)b:c6 *b+b,b-bdf?c7 .b@c8 /b[c9 :b]c! ;b^c# =b_c$ ?b`c% @bIc' Z {c( [bD EcFcxb|c}cw S ~cadbd) ]bcd* ^bobm t dd+ _be x y q , - . / i T U K `b{bg |b}bed: ~bfd; acgd= bchd? ccid@ dcjd[ eckd] fcld^ gcmd_ hcJc` 0 nd{ icE GcHcybodpdz V qdrdsd| jctd} kcpbn u ud~ lcf A B r abbbcbdbj W X L mcnch ocpcvdebqcwdfbrcxdgbsc7cC qbydhbtczdibucAdjbvcBdkbwcCdlbxcDdmbycEdnbzc

216  

217 @property 

218 def bytesize(self) -> int: 

219 """The number of bytes allocated.""" 

220 return self._bytesize 2efffo p

221  

222 @property 

223 def device_id(self) -> int: 

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

225 return self._device_id 2efffo p

226  

227 @property 

228 def memory_type(self) -> str: 

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

230 return self._memory_type 2efffo p

231  

232 @property 

233 def peer_access(self) -> tuple: 

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

235 return self._peer_access 2efffo p

236  

237 @property 

238 def options(self): 

239 """A GraphAllocOptions reconstructed from this node's parameters.""" 

240 from cuda.core.graph._graph_definition import GraphAllocOptions 2efffo p

241 return GraphAllocOptions( 2efffo p

242 device=self._device_id, 2efffo p

243 memory_type=self._memory_type, 

244 peer_access=list(self._peer_access) if self._peer_access else None, 2efffo p

245 ) 

246  

247  

248cdef class FreeNode(GraphNode): 

249 """A memory deallocation node. 

250  

251 Properties 

252 ---------- 

253 dptr : int 

254 The device pointer being freed. 

255 """ 

256  

257 @staticmethod 

258 cdef FreeNode _create_with_params(GraphNodeHandle h_node, 

259 cydriver.CUdeviceptr dptr): 

260 """Create from known params (called by free() builder).""" 

261 cdef FreeNode n = FreeNode.__new__(FreeNode) 2$c%c'c(c)c*ca b c d O P Q R +c,c-c.c/c:c?c@c[c]c^c_c`cIc{cD EcFcxb|c}cw S ~cadbdcdobddedfdgdhdidjdkdldmdJcndE GcHcybodpdz V qdrdsdtdpbudvdwdxd7cydzdAdBdCdDdEd

262 n._h_node = h_node 2$c%c'c(c)c*ca b c d O P Q R +c,c-c.c/c:c?c@c[c]c^c_c`cIc{cD EcFcxb|c}cw S ~cadbdcdobddedfdgdhdidjdkdldmdJcndE GcHcybodpdz V qdrdsdtdpbudvdwdxd7cydzdAdBdCdDdEd

263 n._dptr = dptr 2$c%c'c(c)c*ca b c d O P Q R +c,c-c.c/c:c?c@c[c]c^c_c`cIc{cD EcFcxb|c}cw S ~cadbdcdobddedfdgdhdidjdkdldmdJcndE GcHcybodpdz V qdrdsdtdpbudvdwdxd7cydzdAdBdCdDdEd

264 return n 2$c%c'c(c)c*ca b c d O P Q R +c,c-c.c/c:c?c@c[c]c^c_c`cIc{cD EcFcxb|c}cw S ~cadbdcdobddedfdgdhdidjdkdldmdJcndE GcHcybodpdz V qdrdsdtdpbudvdwdxd7cydzdAdBdCdDdEd

265  

266 @staticmethod 

267 cdef FreeNode _create_from_driver(GraphNodeHandle h_node): 

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

269 cdef cydriver.CUgraphNode node = as_cu(h_node) 

270 cdef cydriver.CUdeviceptr dptr 

271 with nogil: 

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

273 return FreeNode._create_with_params(h_node, dptr) 

274  

275 def __repr__(self) -> str: 

276 return f"<FreeNode handle=0x{as_intptr(self._h_node):x} dptr=0x{self._dptr:x}>" 27c

277  

278 @property 

279 def dptr(self) -> int: 

280 """The device pointer being freed.""" 

281 return self._dptr 2Viwb

282  

283  

284cdef class MemsetNode(GraphNode): 

285 """A memset node. 

286  

287 Properties 

288 ---------- 

289 dptr : int 

290 The destination device pointer. 

291 value : int 

292 The fill value. 

293 element_size : int 

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

295 width : int 

296 Width of the row in elements. 

297 height : int 

298 Number of rows. 

299 pitch : int 

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

301 """ 

302  

303 @staticmethod 

304 cdef MemsetNode _create_with_params(GraphNodeHandle h_node, 

305 cydriver.CUdeviceptr dptr, unsigned int value, 

306 unsigned int element_size, size_t width, 

307 size_t height, size_t pitch): 

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

309 cdef MemsetNode n = MemsetNode.__new__(MemsetNode) 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

310 n._h_node = h_node 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

311 n._dptr = dptr 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

312 n._value = value 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

313 n._element_size = element_size 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

314 n._width = width 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

315 n._height = height 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

316 n._pitch = pitch 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

317 return n 2a b c d O P Q R BbCbDbEbFbGbHbIbJbKbLbMbVbXbZb1b!b$b'b)b*b+b,b-bk Xd.b/b:b;b=b?b@bZ [bS ]b^bt _bi T U K `b{bg |b}b~bacbcccdcecfcgchc0 icV jckcu lcj W X L mcnch ocpcqcrcscqbtcucvcwcxcyczc

318  

319 @staticmethod 

320 cdef MemsetNode _create_from_driver(GraphNodeHandle h_node): 

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

322 cdef cydriver.CUgraphNode node = as_cu(h_node) 1k

323 cdef cydriver.CUDA_MEMSET_NODE_PARAMS params 

324 with nogil: 1k

325 HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams(node, &params)) 1k

326 return MemsetNode._create_with_params( 1k

327 h_node, params.dst, params.value, 

328 params.elementSize, params.width, params.height, params.pitch) 1k

329  

330 def __repr__(self) -> str: 

331 return (f"<MemsetNode handle=0x{as_intptr(self._h_node):x}" 2qb

332 f" dptr=0x{self._dptr:x} value={self._value}>") 2qb

333  

334 @property 

335 def dptr(self) -> int: 

336 """The destination device pointer.""" 

337 return self._dptr 27g8g9g!gG H I J Xd

338  

339 @property 

340 def value(self) -> int: 

341 """The fill value.""" 

342 return self._value 27g8g9g!gG H I J Xd

343  

344 @property 

345 def element_size(self) -> int: 

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

347 return self._element_size 27g8g9g!gG H I J

348  

349 @property 

350 def width(self) -> int: 

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

352 return self._width 27g8g9g!gG H I J Xd

353  

354 @property 

355 def height(self) -> int: 

356 """Number of rows.""" 

357 return self._height 27g8g9g!gG H I J

358  

359 @property 

360 def pitch(self) -> int: 

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

362 return self._pitch 27g8g9g!gG H I J

363  

364  

365cdef class MemcpyNode(GraphNode): 

366 """A memcpy node. 

367  

368 Properties 

369 ---------- 

370 dst : int 

371 The destination pointer. 

372 src : int 

373 The source pointer. 

374 size : int 

375 The number of bytes copied. 

376 """ 

377  

378 @staticmethod 

379 cdef MemcpyNode _create_with_params(GraphNodeHandle h_node, 

380 cydriver.CUdeviceptr dst, cydriver.CUdeviceptr src, 

381 size_t size, cydriver.CUmemorytype dst_type, 

382 cydriver.CUmemorytype src_type): 

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

384 cdef MemcpyNode n = MemcpyNode.__new__(MemcpyNode) 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

385 n._h_node = h_node 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

386 n._dst = dst 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

387 n._src = src 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

388 n._size = size 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

389 n._dst_type = dst_type 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

390 n._src_type = src_type 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

391 return n 2a b c d 1 2 3 4 5 6 7 8 9 ! # $ % ' ( w ) * m + e x y q , - . / g : ; = ? @ [ ] ^ _ ` { z | } n ~ f A B r abbbcbdbh ebfbgbC hbibjbkblbmbnb

392  

393 @staticmethod 

394 cdef MemcpyNode _create_from_driver(GraphNodeHandle h_node): 

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

396 cdef cydriver.CUgraphNode node = as_cu(h_node) 

397 cdef cydriver.CUDA_MEMCPY3D params 

398 with nogil: 

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

400  

401 cdef cydriver.CUdeviceptr dst 

402 cdef cydriver.CUdeviceptr src 

403 if params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

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

405 else: 

406 dst = params.dstDevice 

407 if params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

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

409 else: 

410 src = params.srcDevice 

411  

412 return MemcpyNode._create_with_params( 

413 h_node, dst, src, params.WidthInBytes, 

414 params.dstMemoryType, params.srcMemoryType) 

415  

416 def __repr__(self) -> str: 

417 cdef str dt = "H" if self._dst_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1C

418 cdef str st = "H" if self._src_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1C

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

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

421  

422 @property 

423 def dst(self) -> int: 

424 """The destination pointer.""" 

425 return self._dst 2Piv

426  

427 @property 

428 def src(self) -> int: 

429 """The source pointer.""" 

430 return self._src 2Piv

431  

432 @property 

433 def size(self) -> int: 

434 """The number of bytes copied.""" 

435 return self._size 2Piv

436  

437  

438cdef class ChildGraphNode(GraphNode): 

439 """A child graph node. 

440  

441 Properties 

442 ---------- 

443 child_graph : GraphDefinition 

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

445 """ 

446  

447 @staticmethod 

448 cdef ChildGraphNode _create_with_params(GraphNodeHandle h_node, 

449 GraphHandle h_child_graph): 

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

451 cdef ChildGraphNode n = ChildGraphNode.__new__(ChildGraphNode) 2zeAeBeCeDeEeFerbs GeHesbIe0c1cCcJeKeLeMeNeOePeM QeD ReSeTeWee i XeYeZe0etb1e3c4cDc2e3e4e5e6e7e8eN 9eE !e#e$e(ef j )e*e+e#c,e-e.e/e:e;e=e

452 n._h_node = h_node 2zeAeBeCeDeEeFerbs GeHesbIe0c1cCcJeKeLeMeNeOePeM QeD ReSeTeWee i XeYeZe0etb1e3c4cDc2e3e4e5e6e7e8eN 9eE !e#e$e(ef j )e*e+e#c,e-e.e/e:e;e=e

453 n._h_child_graph = h_child_graph 2zeAeBeCeDeEeFerbs GeHesbIe0c1cCcJeKeLeMeNeOePeM QeD ReSeTeWee i XeYeZe0etb1e3c4cDc2e3e4e5e6e7e8eN 9eE !e#e$e(ef j )e*e+e#c,e-e.e/e:e;e=e

454 return n 2zeAeBeCeDeEeFerbs GeHesbIe0c1cCcJeKeLeMeNeOePeM QeD ReSeTeWee i XeYeZe0etb1e3c4cDc2e3e4e5e6e7e8eN 9eE !e#e$e(ef j )e*e+e#c,e-e.e/e:e;e=e

455  

456 @staticmethod 

457 cdef ChildGraphNode _create_from_driver(GraphNodeHandle h_node): 

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

459 cdef cydriver.CUgraphNode node = as_cu(h_node) 1s

460 cdef cydriver.CUgraph child_graph = NULL 1s

461 with nogil: 1s

462 HANDLE_RETURN(cydriver.cuGraphChildGraphNodeGetGraph(node, &child_graph)) 1s

463 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 1s

464 cdef GraphHandle h_child = create_graph_handle_ref(child_graph, h_graph) 1s

465 return ChildGraphNode._create_with_params(h_node, h_child) 1s

466  

467 def __repr__(self) -> str: 

468 return (f"<ChildGraphNode handle=0x{as_intptr(self._h_node):x}" 2#c

469 f" child=0x{as_intptr(self._h_child_graph):x}>") 2#c

470  

471 @property 

472 def child_graph(self) -> "GraphDefinition": 

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

474 return GraphDefinition._from_handle(self._h_child_graph) 2PcWirbs

475  

476  

477cdef class EventRecordNode(GraphNode): 

478 """An event record node. 

479  

480 Properties 

481 ---------- 

482 event : Event 

483 The event being recorded. 

484 """ 

485  

486 @staticmethod 

487 cdef EventRecordNode _create_with_params(GraphNodeHandle h_node, 

488 EventHandle h_event): 

489 """Create from known params (called by record_event() builder).""" 

490 cdef EventRecordNode n = EventRecordNode.__new__(EventRecordNode) 2bgHdJdLdNdPdRdKh;cLhcgdgGdPhQhTdRh0cShThUhLcVheg`eWhXhYhZhEc0h1hUe2hx T 3h4h5h6hVd7h3c8h9h!hNc#hfg{e$h%h'h(hGc)h*h%e+hA W ,h-h.h#g/h:h;h=h?h@h[h

491 n._h_node = h_node 2bgHdJdLdNdPdRdKh;cLhcgdgGdPhQhTdRh0cShThUhLcVheg`eWhXhYhZhEc0h1hUe2hx T 3h4h5h6hVd7h3c8h9h!hNc#hfg{e$h%h'h(hGc)h*h%e+hA W ,h-h.h#g/h:h;h=h?h@h[h

492 n._h_event = h_event 2bgHdJdLdNdPdRdKh;cLhcgdgGdPhQhTdRh0cShThUhLcVheg`eWhXhYhZhEc0h1hUe2hx T 3h4h5h6hVd7h3c8h9h!hNc#hfg{e$h%h'h(hGc)h*h%e+hA W ,h-h.h#g/h:h;h=h?h@h[h

493 return n 2bgHdJdLdNdPdRdKh;cLhcgdgGdPhQhTdRh0cShThUhLcVheg`eWhXhYhZhEc0h1hUe2hx T 3h4h5h6hVd7h3c8h9h!hNc#hfg{e$h%h'h(hGc)h*h%e+hA W ,h-h.h#g/h:h;h=h?h@h[h

494  

495 @staticmethod 

496 cdef EventRecordNode _create_from_driver(GraphNodeHandle h_node): 

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

498 cdef cydriver.CUgraphNode node = as_cu(h_node) 

499 cdef cydriver.CUevent event 

500 with nogil: 

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

502 cdef EventHandle h_event = create_event_handle_ref(event) 

503 return EventRecordNode._create_with_params(h_node, h_event) 

504  

505 def __repr__(self) -> str: 

506 return (f"<EventRecordNode handle=0x{as_intptr(self._h_node):x}" 2#g

507 f" event=0x{as_intptr(self._h_event):x}>") 2#g

508  

509 @property 

510 def event(self) -> Event: 

511 """The event being recorded.""" 

512 return Event._from_handle(self._h_event) 2XiubKh;cLh

513  

514  

515cdef class EventWaitNode(GraphNode): 

516 """An event wait node. 

517  

518 Properties 

519 ---------- 

520 event : Event 

521 The event being waited on. 

522 """ 

523  

524 @staticmethod 

525 cdef EventWaitNode _create_with_params(GraphNodeHandle h_node, 

526 EventHandle h_event): 

527 """Create from known params (called by wait_event() builder).""" 

528 cdef EventWaitNode n = EventWaitNode.__new__(EventWaitNode) 2bgIdKdMdOdQdSdcgdg=cMh]h^hUd_h1c`h{h|hMc}heg|e~haibiciFcdieiVefiy U gihiiijiWdki4climiniOcoifg}epiqirisiHctiui'eviB X wixiyi$gziAiBiCiDiEiFi

529 n._h_node = h_node 2bgIdKdMdOdQdSdcgdg=cMh]h^hUd_h1c`h{h|hMc}heg|e~haibiciFcdieiVefiy U gihiiijiWdki4climiniOcoifg}epiqirisiHctiui'eviB X wixiyi$gziAiBiCiDiEiFi

530 n._h_event = h_event 2bgIdKdMdOdQdSdcgdg=cMh]h^hUd_h1c`h{h|hMc}heg|e~haibiciFcdieiVefiy U gihiiijiWdki4climiniOcoifg}epiqirisiHctiui'eviB X wixiyi$gziAiBiCiDiEiFi

531 return n 2bgIdKdMdOdQdSdcgdg=cMh]h^hUd_h1c`h{h|hMc}heg|e~haibiciFcdieiVefiy U gihiiijiWdki4climiniOcoifg}epiqirisiHctiui'eviB X wixiyi$gziAiBiCiDiEiFi

532  

533 @staticmethod 

534 cdef EventWaitNode _create_from_driver(GraphNodeHandle h_node): 

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

536 cdef cydriver.CUgraphNode node = as_cu(h_node) 

537 cdef cydriver.CUevent event 

538 with nogil: 

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

540 cdef EventHandle h_event = create_event_handle_ref(event) 

541 return EventWaitNode._create_with_params(h_node, h_event) 

542  

543 def __repr__(self) -> str: 

544 return (f"<EventWaitNode handle=0x{as_intptr(self._h_node):x}" 2$g

545 f" event=0x{as_intptr(self._h_event):x}>") 2$g

546  

547 @property 

548 def event(self) -> Event: 

549 """The event being waited on.""" 

550 return Event._from_handle(self._h_event) 2Yivb=cMh

551  

552  

553cdef class HostCallbackNode(GraphNode): 

554 """A host callback node. 

555  

556 Properties 

557 ---------- 

558 callback_fn : callable or None 

559 The Python callable (None for ctypes function pointer callbacks). 

560 """ 

561  

562 @staticmethod 

563 cdef HostCallbackNode _create_with_params(GraphNodeHandle h_node, 

564 object callable_obj, cydriver.CUhostFn fn, 

565 void* user_data): 

566 """Create from known params (called by callback() builder).""" 

567 cdef HostCallbackNode n = HostCallbackNode.__new__(HostCallbackNode) 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

568 n._h_node = h_node 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

569 n._callable = callable_obj 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

570 n._fn = fn 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

571 n._user_data = user_data 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

572 return n 2%g'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g5c{gCc|g}g~gAcah`e|exbbhchdhehfhgh9chhq K ihjhkhlh6cmhDcnhohphBcqh{e}eybrhshthuhvhwh!cxhr L yhzhAh~eBhChDhEhFhGhHh

573  

574 @staticmethod 

575 cdef HostCallbackNode _create_from_driver(GraphNodeHandle h_node): 

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

577 cdef cydriver.CUgraphNode node = as_cu(h_node) 

578 cdef cydriver.CUDA_HOST_NODE_PARAMS params 

579 with nogil: 

580 HANDLE_RETURN(cydriver.cuGraphHostNodeGetParams(node, &params)) 

581  

582 cdef object callable_obj = None 

583 if _is_py_host_trampoline(params.fn): 

584 callable_obj = <object>params.userData 

585  

586 return HostCallbackNode._create_with_params( 

587 h_node, callable_obj, params.fn, params.userData) 

588  

589 def __repr__(self) -> str: 

590 if self._callable is not None: 2~e

591 name = getattr(self._callable, '__name__', '?') 2~e

592 return (f"<HostCallbackNode handle=0x{as_intptr(self._h_node):x}" 2~e

593 f" callback={name}>") 2~e

594 return (f"<HostCallbackNode handle=0x{as_intptr(self._h_node):x}" 

595 f" cfunc=0x{<uintptr_t>self._fn:x}>") 

596  

597 @property 

598 def callback_fn(self): 

599 """The Python callable, or None for ctypes function pointer callbacks.""" 

600 return self._callable 2Zi0i

601  

602  

603cdef class ConditionalNode(GraphNode): 

604 """Base class for conditional nodes. 

605  

606 When created via builder methods (if_cond, if_else, while_loop, switch), 

607 a specific subclass (IfNode, IfElseNode, WhileNode, SwitchNode) is 

608 returned. When reconstructed from the driver on CUDA 13.2+, the 

609 correct subclass is determined via cuGraphNodeGetParams. On older 

610 drivers, this base class is used as a fallback. 

611  

612 Properties 

613 ---------- 

614 condition : GraphCondition or None 

615 The condition variable controlling execution (None pre-13.2). 

616 cond_type : str or None 

617 The conditional type ("if", "while", or "switch"; None pre-13.2). 

618 branches : tuple of GraphDefinition 

619 The body graphs for each branch (empty pre-13.2). 

620 """ 

621  

622 @staticmethod 

623 cdef ConditionalNode _create_from_driver(GraphNodeHandle h_node): 

624 cdef ConditionalNode n 

625 if not _check_node_get_params(): 28c

626 n = ConditionalNode.__new__(ConditionalNode) 28c

627 n._h_node = h_node 28c

628 n._condition = None 28c

629 n._cond_type = cydriver.CU_GRAPH_COND_TYPE_IF 28c

630 n._branches = () 28c

631 return n 28c

632  

633 cdef cydriver.CUgraphNode node = as_cu(h_node) 

634 params = handle_return(driver.cuGraphNodeGetParams( 

635 <uintptr_t>node)) 

636 cond_params = params.conditional 

637 cdef int cond_type_int = int(cond_params.type) 

638 cdef unsigned int size = int(cond_params.size) 

639  

640 cdef GraphCondition condition = GraphCondition.__new__(GraphCondition) 

641 condition._c_handle = <cydriver.CUgraphConditionalHandle>( 

642 <unsigned long long>int(cond_params.handle)) 

643  

644 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 

645 cdef list branch_list = [] 

646 cdef unsigned int i 

647 cdef GraphHandle h_branch 

648 if cond_params.phGraph_out is not None: 

649 for i in range(size): 

650 h_branch = create_graph_handle_ref( 

651 <cydriver.CUgraph><uintptr_t>int(cond_params.phGraph_out[i]), 

652 h_graph) 

653 branch_list.append(GraphDefinition._from_handle(h_branch)) 

654 cdef tuple branches = tuple(branch_list) 

655  

656 cdef type cls 

657 if cond_type_int == <int>cydriver.CU_GRAPH_COND_TYPE_IF: 

658 if size == 1: 

659 cls = IfNode 

660 else: 

661 cls = IfElseNode 

662 elif cond_type_int == <int>cydriver.CU_GRAPH_COND_TYPE_WHILE: 

663 cls = WhileNode 

664 else: 

665 cls = SwitchNode 

666  

667 n = cls.__new__(cls) 

668 n._h_node = h_node 

669 n._condition = condition 

670 n._cond_type = <cydriver.CUgraphConditionalNodeType>cond_type_int 

671 n._branches = branches 

672 return n 

673  

674 def __repr__(self) -> str: 

675 return f"<ConditionalNode handle=0x{as_intptr(self._h_node):x}>" 

676  

677 @property 

678 def condition(self) -> GraphCondition | None: 

679 """The condition variable controlling execution.""" 

680 return self._condition 2Ih5gNhJh

681  

682 @property 

683 def cond_type(self) -> str | None: 

684 """The conditional type as a string: 'if', 'while', or 'switch'. 

685  

686 Returns None when reconstructed from the driver pre-CUDA 13.2, 

687 as the conditional type cannot be determined. 

688 """ 

689 if self._condition is None: 2Ih5gNhJh

690 return None 

691 if self._cond_type == cydriver.CU_GRAPH_COND_TYPE_IF: 2Ih5gNhJh

692 return "if" 2Ih5g

693 elif self._cond_type == cydriver.CU_GRAPH_COND_TYPE_WHILE: 

694 return "while" 2Jh

695 else: 

696 return "switch" 2Nh

697  

698 @property 

699 def branches(self) -> tuple: 

700 """The body graphs for each branch as a tuple of GraphDefinition. 

701  

702 Returns an empty tuple when reconstructed from the driver 

703 pre-CUDA 13.2. 

704 """ 

705 return self._branches 2Ih5gNhJh1iXc8c

706  

707  

708cdef class IfNode(ConditionalNode): 

709 """An if-conditional node.""" 

710  

711 def __repr__(self) -> str: 

712 return (f"<IfNode handle=0x{as_intptr(self._h_node):x}" 2Qi

713 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Qi

714  

715 @property 

716 def then(self) -> "GraphDefinition": 

717 """The 'then' branch graph.""" 

718 return self._branches[0] 2Ih2iWc

719  

720  

721cdef class IfElseNode(ConditionalNode): 

722 """An if-else conditional node.""" 

723  

724 def __repr__(self) -> str: 

725 return (f"<IfElseNode handle=0x{as_intptr(self._h_node):x}" 2Ri

726 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Ri

727  

728 @property 

729 def then(self) -> "GraphDefinition": 

730 """The ``then`` branch graph (executed when condition is non-zero).""" 

731 return self._branches[0] 25gSiKc

732  

733 @property 

734 def else_(self) -> "GraphDefinition": 

735 """The ``else`` branch graph (executed when condition is zero).""" 

736 return self._branches[1] 25gSiKc

737  

738  

739cdef class WhileNode(ConditionalNode): 

740 """A while-loop conditional node.""" 

741  

742 def __repr__(self) -> str: 

743 return (f"<WhileNode handle=0x{as_intptr(self._h_node):x}" 2Ti

744 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Ti

745  

746 @property 

747 def body(self) -> "GraphDefinition": 

748 """The loop body graph.""" 

749 return self._branches[0] 2Jh3iYc

750  

751  

752cdef class SwitchNode(ConditionalNode): 

753 """A switch conditional node.""" 

754  

755 def __repr__(self) -> str: 

756 return (f"<SwitchNode handle=0x{as_intptr(self._h_node):x}" 2Ui

757 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Ui