Coverage for cuda/bindings/cydriver.pyx: 67.06%

3# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE

5# This code was automatically generated across versions from 12.9.0 to 13.3.0, generator version 0.3.1.dev1622+g48467ab08.d20260421. Do not modify it directly.

7from ._internal cimport driver as _driver

9cdef CUresult cuGetErrorString(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

10 return _driver._cuGetErrorString(error, pStr) 3 ctx2aMkybM

13cdef CUresult cuGetErrorName(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

14 return _driver._cuGetErrorName(error, pStr) 14 ctx2;rAl=rBlCl=bDlaMkybMdZ} Hh|i

17cdef CUresult cuInit(unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

18 return _driver._cuInit(Flags) 70 ctx2a ly?rmynyoypyqyrysytyuyvywyxyyyzyAyByCy@r[r]r^r_r`r{r^p|r}r~rasbscsdsesfsgshsisjskslsmsnsospsqsDyEyFyGyHyIyJyKyLyMyNyOyPyQyRySy?beZTyUyVyWy

21cdef CUresult cuDriverGetVersion(int* driverVersion) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

22 return _driver._cuDriverGetVersion(driverVersion) 7 ctx2a fZgZhZiZjZkZ

25cdef CUresult cuDeviceGet(CUdevice* device, int ordinal) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

26 return _driver._cuDeviceGet(device, ordinal) 67 ctx2lymynyoypyqyrysytyuyvywyxyyyzyAykyByCy@r[r]r^r_r`r{r^p|r}r~rasbscsdsesfsgshsisjskslsmsnsospsqsDyEyFyGyHyIyJyKyLyMyNyOyPyQyRySyTyUyVyWy

29cdef CUresult cuDeviceGetCount(int* count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

30 return _driver._cuDeviceGetCount(count) 1838 ctx2a rscMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzMAMBMCMDMEMFMGMHMIMXyYyZy0ylZ1y2y3y4y5yEl}iFl6y~iGlHl7y8y9y!y#yJM$y%y'y(y)y*y+y,y-y.y/y:y;y=y?y@y[y]y^y_y`y{y|y}y~yazbzczdzezfzgzhzizIlJl@baj{d|dbjKlLlMlNlod}dIhJhKhLhOlPlQlRl[bcj~daedjSlTlUlVlpdbeMhNhOhPhWlXlYlejZljzfj0l1l2lgj3lhj4l5l6l7l]bijcedejj8l9l!l#lqdeeQhRhShTh$l%l'l(l^bkjfegelj)l*l+l,lrdheUhVhWhXh-l.l/l:l_bmjiejenj;l=l?l@lsdkeYhZh0h1h[l]l^l_l`bojlemepj`l{l|l}ltdne2h3h4h5h~lambmqjcmrjdmemfmsjgmtjhmimKMjmujkmvjlmmmLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM0M1M2M3M4M5M6M7M8M9M!M#M$M%M'M(M)M*M~ +M,M-M.M/M:M;M=M?M@M[M]M^M_M`M{M|M}M~MaNbNcNdNeNfNgNhNiNkzjNkNlNmNnNoNpNqN_p`prNss{pnm|p}p~paqbqsNomwjtspmxjqmyjuscqdqeqfqgqhqiqjqtNuNlzmznzoeozkqpzqzperzqezjsz% vsgghgtzuzvzwzxzyzzzAzBzCzDzEzFzGzHzIzJzKzLzMzNzOzPzQzRzSzlqrermmqigQbmZabbb+ RbSbse6hnqAjcbdbebfbwsgbhb?rvNwNxNyNzNANBNCNDNxsyszsAsBsCsDsEsFsGsHsIsJsKsLsTc0 UcENsmFNGNHNINJNKNLNMNNNONPNjgTzBjCjtetmumDjEjFjQNGjHjIjUzVzWzXzYzZz0z1z2z3z4z5z6z7z8z9z!z#zRNueSNVcWcXcYcMsNsOsPsQsRsSsTsUsVsWsXsYsZs0s1s2s3s4s5s6s7s8s9s!s#s$s%s's(s)s*s+s,s-s{bkglgoqpq.s/s:s;s=s?s@s[s]s^s_s`s{s|s}s~satbtctdtetftgthtitjtktltmtntotptqtrtstttutvt$z%zTb'zwt|bTN7hUN8h9hVNWNibud(z!hXNveYNvd}b#hweZN$hxe%hye'hzewd~b(hmgngZc0Nog1Npgqg2Nrg3Nxdsg)h4NAe5Nyd6Nac*hBe7N+hCe,h8NDe9N-hEe!Nzd#Nbc.hFetgug$N/hAd%N0c'NBdJjxtvmccCdUbdcGewm(N:h;h} )NqqnZ*Nxmym+Nzm,NAmBmCmM -NDmHh.N/N:N;N=N?N@N[N]N^NEmFmGmHmytztAtBtCtDtEtFtGtImJmKmLmMmNmOmPmQmRmSmTmUmVmWmXmYmZm0m1m2m3m4m5m6m7m8m9m!m#m$m%m'm(m)m*m+m,m-m.m/m:m;m=m?m@m[m]m^m_m`m{m|m}m~manbncndnenfngnhninjnknlnmnKjecrq_N`NLj)zMjNjOj*znnonpnqnHeIe=hsq+zHtrnsnPjtnItunQjfctq{N,zRj-zSjTjUj.zvnwnxnynJeKe?huq/zJtznAnVbLeMeVjvgwgxgDdNe@hygzgOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdjbkbYb, - . / ^hlbBgCgDgEg_hBnCn5cKdFgvqDnEnXjgcwqYjZj0j1j:zFnGnHnInRe|NSe`hxq;zJnKn2j{hZbLn=z|hKt}h~haiLt3j4j5j6jLd?zMdGgMnMtyq7j8j9jmbNdOdbiTeUeVe6cWeHgXeYeci0bNn@zdi!j#jeiNt$j%j'j(jPd[zQdIgOnOt)j*jfigiZe0e1e2ehi3e4e5e6enbRdSd7e8e9eTdJg!e#ePnhczq+j,j-j.jQnRnSn$e%eii]zTnUnKgLgMgNgVnWnXnYnZnjiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncoc0npcAq;j=j?j@j^z1n2n3n4n.e/ekiBq_z5n6n3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jrclimi@e[eni7nRgSgTg8n]eZdUg9nVgWg!nsc]j^j_j`j#n$n%n^e_eoi'n(npiXgpb{jPtYgCqZg0g1gDqqirisi*cQt+c`e|jEqtiui)n*n}jtcFq}N~N~j`zakbkck{z+n,n-n.n{e|eviGq|zRt/n:n3b}e~edk2g3g4g0dafwi5g6gbf( cf1d,c2dxi3d4d5ddf4bek5b-cyizi6d7dqbrb6b; = ? @ Aisb7g8g9g!gBi;n=n.c8d#gHq?n@n[nfkucIqgkhkikjk}z]n^n_n`nefaOffCiSt~z{n|n}nkkvcJqbOlkaAmknkokbA~naobocogfcOhfDiTtcAUtdoeopktb9d!dEiifjfkf/clf$gmfnfqkFi7bfodAGirkskHiVttkukvkwk#deA$d%gKqWtxkykIiJiofpfqfrfKisftfufvfub%d'dwfxfyf(d'gzfAfgowcLqzkAkBkCkhoiojoBfCfLifAkolo(g)g*g+gmonooopoqoMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcroEcMqFkGkHkIkgAsotouovoKfLfNiXthAwoxo4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoGcJkKk/g:gLkNqOiPiQizoQfRfRiOqSiTiAoHcMkNkOkPkBoCoDoSfTfUiEoFoVi;gwbQkYt=gPq?g@g[gQqWiXiYiZi{cZt|cUfGoRq0i1iHodOeO}c?b.d/d0t1tIoRkIcSqfOiASkjATkUkVkkAJoKoLoMoVfWf2iTqUqgO2t3thOlA4tNoOoPoWkJcVqiOjOXkmAYkZk0knAQoRoSoToXfYf3iWqoA5tUoVoWo1kKcXqkOpA2kqA3k4k5krAXoYoZo0oZf0f4iYqsA6t1o2o3o6kLcZqlOtA7kuA8k9k!kvA4o5o6o7o1f2f5i0qwA7t8o9o!o#kMc1qmOxA$kyA%k'k(kzA#o$o%o'o3f4f6i2qAA8t(o)o*o)kNc3qnOBA*kCA+k,k-kDA+o,o-o.o5f6f7i4qEA9t/o:o;o.kOc5qoOpO/kFA:k;k=kGA=o?o@o[o7f8f8i!t#tHA$t]o^o_o?kPc6qqOrO@kIA[k]k^kJA`o{o|o9f!f9i%t'tKA(t}o~osOtO)tuOvOwOxOyOzOAOBOCODOEOFOGOHOIOJOKOLOMONOOOPOQOROSOTOUOVOWOXOYOZO*t+t|i0O1O2O3O4O5O6O7O8O9O!O,t-t.t/t:t;t=t?t@t[t]t#O$O%O'O(O)O*O+O,O-O.O/O:O;O=O?O@O[O]O^O_O`O{O|O}O~OaPbPcPdPePfPgPhPiPjP^t_t`t{t|t}t~taubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzuAuBuCuDuEukPlPmPFuGuHunPoPpPqPrPsPtPuPvPwPxPyP#f$f%f'f(f)f*f+f,f-f.f/f:f;f=f?f@f[f]f^f_f`f{f|f}fzPAPBPCPDPEPFPGPHPIPJPKPLPMPNPOPPPQPRPSPTPUP

33cdef CUresult cuDeviceGetName(char* name, int len, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

34 return _driver._cuDeviceGetName(name, len, dev) 43 ctx2nmuNoZapoekqIupeqe% ] bp]g!i#icpdpepfpgghglqreJuKumqLuigQbabbb+ ~fRbSbse6hnq7q?rVPLAiA

37cdef CUresult cuDeviceGetUuid(CUuuid* uuid, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

38 return _driver._cuDeviceGetUuid_v2(uuid, dev) 72 ctx2nm}pzjvs8qgprm9qAjwsvNpZqZrZsZtZMANAve}bwexeyeze~bmgAeacBeCeDeEebcFetgdc:h;hOA,z2j{hZbLn=z|hKt}h~haiLt3j4j5j6jLd?zMdGgMnMtyq7j8j}c?b.d/dpAtAxABA

41cdef CUresult cuDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

42 return _driver._cuDeviceGetLuid(luid, deviceNodeMask, dev)

45cdef CUresult cuDeviceTotalMem(size_t* bytes, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

46 return _driver._cuDeviceTotalMem_v2(bytes, dev)

49cdef CUresult cuDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, CUarray_format format, unsigned numChannels, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

50 return _driver._cuDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, format, numChannels, dev)

53cdef CUresult cuDeviceGetAttribute(int* pi, CUdevice_attribute attrib, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

54 return _driver._cuDeviceGetAttribute(pi, attrib, dev) 1311 ctx2a rsS T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J PAQA!q;rMuRANuEl}iFl~iGlHl#q~cadbd:d2 uZvZybzbAb!bBb6 7 8 * #b$b%bQcwZ$q%q'q(q)q*q$i_kIlJl@baj{d|dbjod}dIhJhKhLhQlRl[bcj~daedjpdbeMhNhOhPhYlejZlfj0l1l2lgj3lhj4l5l6l7l]bijcedejjqdeeQhRhShTh'l(l^bkjfegeljrdheUhVhWhXh/l:l_bmjiejenjsdkeYhZh0h1h^l_l`bojlemepjtdne2h3h4h5hbmqjcmrjdmemfmsjgmtjhmimjmujkmvjlmmmxZ`k+q;dyZcdzZWPXPYPZP0P1PCbDbEbFb'b=d?dK N ,qagX ^ _ (bO L A B b 9 kzw E Y Z Gb)b*bddU _p`p{p|p~paqbq-qomwjtspmxjqmyjuscqdqOueqfqgqhqiqjqzj% ] .qvs8q/qgprm:q9q;qAjws?rhpSATA^g_gxsUAVAWAXAYAZA0A1A2Ays3A4Azs5A6A7A8A9A!A#A$A%AAs'A(A)A*A+A,A-A.A/ABs:A;A=A?A@A[A]A^A_ACs`A{A|A}A~AaBbBDscBdBeBfBgBhBiBjBkBlBmBnBEsoBpBFsqBrBsBtBuBvBwBxByBzBABBBCBGsDBEBFBHsGBHBIBJBKBIsLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB0B1B2B3B4B5B6B7B8B9B!B#B$BJs%B'B(BKs)BLs*B+B,B-B.B/B:B;B=B?B@B[B]B^B_B0 ` RcHbteV tmW umAZBZIb@d[d%i'i(ibg)i*i]d2PVcWcXcYcMsNsOsPsQsRsSsTsUsVsWsXsYsZs0s1s2s3s4s5s6s7s8s9s!s#s$s%s's(s)s*s+s`B,s-skglg+i,i%zTb'z3P{k|bPu|kQu7h8h9hRuib-iud}k!hvevd}b#hwe$hxe%hye'hzewd~b(hng{BZc|Bog}Bpg~BqgaCrgbCcCsgdC)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBd4PCd.i~kUbdcGewm:h;h5Pedfd} 6Pgdqq7Pxmym=qzm?qAmBmCmM DmHh@q[q]q^q_q`q{q|q}q~qEmFmGmHmytztAtBtCtDtEtFtGteCImfCJmgCKmhCLmiCMmjCNmSuOmTuPmUuQmVuRmWuSmXuTmYuUmZuVm0uWm1uXm2uYm3uZm4u0m5u1m6u2m7u3m8u4m9u5m6m7mkC8mlC9mmC!mnC#moC$mpC%mqC'mrC(msC)mtC*muC+mvC,mwC-mxC.myC/mzC:mAC;mBC=mCC?mDC@mEC[m]m^m_m`m{m|m}m~manbncndnenfngnhnOAmnKjecLjOjqnHeIe=hsqPjtnunQjfcRjUjynJeKe?huqVbLeMeVjvgwgxgDdNe@hygzgOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdjbkbYb, - . / ^hlbBgEg5cKdFgEnXjgcYj1jInReSe`hxq2j{hZb|hai6jLdMdGgMn9jmbNdOdbiTeUeVe6cWeHgXeYeci0bdiei(jPdQdIgOnnbRdSd7e8e9eTdJg!e#ePnhc+j.j$e%eiijiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncoc0npc;j@j4n.e/ekiBq3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jrclimi@e[eni7nRgSgTg8n]eZdUg9nVgWg!nsc]j`j^e_eoipiXgpbYg1gsi*c+c`e|j*n}jtc~jck.n{e|eviGq3b}e~edk2g3g4g0dafwi5g6gbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dqbrb6b; = ? @ Aisb7g!g.c8d#g[nfkucgkjk`nefffCiSt}nkkvclkokcogfhfDiTtpktb9d!dEiifjfkf/clf$gmfnfqkFi7bGiHiwk#d$d%gKqub%d'dwfxfyf(d'gzfAfgowczkCkBfCfLiMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcroEcFkIkvoKfLfNiXt4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoGcJkKk/g:gLkNqOiPiQizoQfRfRiOqSiTiAoHcMkPkSfTfUiVi;gwb=g[gZi{c|cUfGo}c?b.d/d0t1tIoRkIcSkVkMoVfWf2iTqUq2t3tPoWkJcXk0kToXfYf3iWqWo1kKc2k5k0oZf0f4iYq3o6kLc7k!k7o1f2f5i0q!o#kMc$k(k'o3f4f6i2q*o)kNc*k-k.o5f6f7i4q;o.kOc/k=k[o7f8f8i!t#t_o?kPc@k^k9f!f9i%t't8P9P)t!P#P$P*t+t|i,t-t.t/t:t;t=t?t@t[t]t%P!u.O^t_t`t{t|t}t~taubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzuAuBuCuDuEuFuGuHu#f$f%f'f(f)f*f+f,f-f.f/f:f;f=f?f@f[f]f^f_f`f{f|f}fip

57cdef CUresult cuDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, CUdevice dev, int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

58 return _driver._cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, dev, flags)

61cdef CUresult cuDeviceSetMemPool(CUdevice dev, CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

62 return _driver._cuDeviceSetMemPool(dev, pool) 1 ctx2'P

65cdef CUresult cuDeviceGetMemPool(CUmemoryPool* pool, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

66 return _driver._cuDeviceGetMemPool(pool, dev) 113 ctx2K N +b,b-bx 9 y z C { D w ^g_gHbV W kglg+i,i$zFC-iCdM KjPjQjOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdXj{hciXg}jbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dfkkkFi;gRkWk1k6k#k)k.k?k#f$f%f'f(f)f*f+f,f-f.f/f:f;f=f?f@f[f]f^f_f`f{f|f}fip

69cdef CUresult cuDeviceGetDefaultMemPool(CUmemoryPool* pool_out, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

70 return _driver._cuDeviceGetDefaultMemPool(pool_out, dev) 1 ctx2'P

73cdef CUresult cuDeviceGetExecAffinitySupport(int* pi, CUexecAffinityType type, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

74 return _driver._cuDeviceGetExecAffinitySupport(pi, type, dev)

77cdef CUresult cuFlushGPUDirectRDMAWrites(CUflushGPUDirectRDMAWritesTarget target, CUflushGPUDirectRDMAWritesScope scope) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

78 return _driver._cuFlushGPUDirectRDMAWrites(target, scope)

81cdef CUresult cuDeviceGetProperties(CUdevprop* prop, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

82 return _driver._cuDeviceGetProperties(prop, dev)

85cdef CUresult cuDeviceComputeCapability(int* major, int* minor, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

86 return _driver._cuDeviceComputeCapability(major, minor, dev)

89cdef CUresult cuDevicePrimaryCtxRetain(CUcontext* pctx, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

90 return _driver._cuDevicePrimaryCtxRetain(pctx, dev) 29 ctx2@r[r]r^r_r`r{r^p|r}r~rasbscsdsesfsgshsisjskslsmsnsospsqsar

93cdef CUresult cuDevicePrimaryCtxRelease(CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

94 return _driver._cuDevicePrimaryCtxRelease_v2(dev) 29 ctx2CZDZEZFZGZHZIZ^pJZKZLZMZNZOZPZQZRZSZTZUZVZWZXZYZZZ0Z1Z2Z3Z

97cdef CUresult cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

98 return _driver._cuDevicePrimaryCtxSetFlags_v2(dev, flags)

100

101cdef CUresult cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int* flags, int* active) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

102 return _driver._cuDevicePrimaryCtxGetState(dev, flags, active)

103

104

105cdef CUresult cuDevicePrimaryCtxReset(CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

106 return _driver._cuDevicePrimaryCtxReset_v2(dev)

107

108

109cdef CUresult cuCtxCreate(CUcontext* pctx, CUctxCreateParams* ctxCreateParams, unsigned int flags, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

110 return _driver._cuCtxCreate_v4(pctx, ctxCreateParams, flags, dev) 38 ctx2lymynyoypyqyrysytyuyvywyxyyyzyAyByCyDyEyFyGyHyIyJyKyLyMyNyOyPyQyRySyTyUyVyWy

111

112

113cdef CUresult cuCtxDestroy(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

114 return _driver._cuCtxDestroy_v2(ctx) 37 ctx24Z5Z6Z7Z8Z9Z!Z#Z$Z%Z'Z(Z)Z*Z+Z,Z-Z.Z/Z:Z;Z=Z?Z@Z[Z]Z^Z_Z`Z{Z|Z}Z~Za0b0c0d0

115

116

117cdef CUresult cuCtxPushCurrent(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

118 return _driver._cuCtxPushCurrent_v2(ctx) 2 ctx2GC(P

119

120

121cdef CUresult cuCtxPopCurrent(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

122 return _driver._cuCtxPopCurrent_v2(pctx) 1707 ctx2)P*P+P,P-P.P/P:P;P=P?P@P[P]P^P_P`P{P|P}P~PaQbQcQdQeQfQgQhQiQjQkQlQmQHCICJCKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZC0C1CnQ2C3C4C5C6C#u7C8CoQpQ9C!C#C$C%C'C(C)C*C+C,C-C.CqQ/C:C;C=C?C@C[C]C^C_C`C{C|C}CrQ$u%u~CaDsQbDcDdDeDfDgDhDiDjDkDlDmDnDtQ'u(uoDpDuQqDrDsDtDuDvDwDxDyDzDADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQD)u*uRDSDTDUDVDWDXDYDZD0D1D2D3D4D5D6D7D+u,u8D9D!D#D$D%D'D(D)D*D+D,D-D.D/D:D;D-u.u=D?D@D[D]D^D_D`D{D|D}D~DaEbEcEdEeE/u:ufEgEhEiEjEkElEmEnEoEpEqErEsEtEuEvEwExEyEzEAEBECEDEvQEEFEGEHEIEJEwQxQyQzQAQBQCQDQEQFQGQHQIQJQKQLQMQNQOQPQQQRQSQTQUQVQWQXQYQZQ0Q1Q2Q3Q4Q5Q6Q7Q8Q9Q!Q#Q$Q%Q'Q(Q)Q*Q+Q,Q-Q.Q/Q:Q;Q=Q?Q@Q[Q]Q^Q_Q`Q{Q|Q}Q~QaRbRcRdReRfRgRhRiRjRKELEMENEkRlROEPEmRQERESETEnRUEVEoRpRqRrRsRtRuRvRwRxRyRzRARBRCRDRERFRGRHRIRJRKRLRMRNRORPRQRRRSRTRURVRWRXRYRZR0R1R2R3R4R5R6R7R8R9R!RWEXEYE#R$RGCZE0E1E%R2E(P3E4E'R(R)R*R+R,R-R.R/R:R;R=R?R@R[R]R^R_R`R{R|R}R~RaSbScSdSeSfSgShSiSjSkSlSmSnSoSpSqSrSsStSuSvSwSxSySzSASBSCSDSESFSGSHSISJSKSLSMSNSOSPSQSRSSSTSUSVSWSXSYSZS0S1S2S3S4S5S6S7S8S9S!S#S$S%S'S(S)S*S+S,S-S.S/S:S;S=S?S@S[S]S^S_S`S{S|S}S~SaTbTcTdTeTfTgThTiTjTkTlTmTnToTpTqTrTsTtTuTvTwTxTyTzTATBTCTDTETFTGTHTITJTKTLTMTNTOTPTQTRTSTTTUTVTWTXTYTZT0T1T2T3T4T5T6T7T8T9T!T#T$T%T'T(T)T*T+T,T-T.T/T:T;T=T?T@T[T]T^T_T`T{T|T}T~TaUbUcUdUeUfUgUhUiUjUkUlUmUnUoUpUqUrUsUtUuUvUwUxUyUzUAUBUCUDUEUFUGUHU5E6E7E8EIUJU9E!E;u=u#E$E%E'E(EKU)E*E+ELU,E-E.E/E:EMU;E=E?E@E[ENUOU]E^E?u@u_E`E{E|E}EPU~EaFbFQUcFdFeFfFgF[u]uhFiFjFkFlFmFnFoFpF^u_u`u{ubrcr|u}u~uavbvqFcvrFdvevsFfvgvhvivjvtFuFvFwFxFyFzFAFkvlvBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFmvnvQFRFSFTFUFRUVFSUWFXFTUYFZF0F1F2F3F4FUU5F6Fovpv7F8F9F!F#FVU$FWU%F'FXU(F)F*F+F,F-Fqvrv.F/F:F;F=F?F@F[F]Fsvtvuvvv^FwvxvyvzvAvBvCvDv_FEv`FFvGv{FHvIvJvKvLvMvNvOvPvQvRvSvTvUv|FVvWv}F~FaGbGcGdGeGfGgGhGiGXvYvjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzGAGBGCGDGEGFGZv0vGGHGIGJGKGLGMGNGOGPGQGRG1v2vSGTGUGVGWGXGYGZG0G1G2G3G3v4v4G5G6G7G8GYU9G!G#GZU$G%G'G(G5v6v)G*G+G,G-G.G7v8v/G:G;G=G?G@G[G]G^G_G9v!v`G{G|G}G~G0UaHbHcHdHeHfHgHhHiH#v$vjHkHlHmHnHoHpHqHrH%v'v(v)vsH*v+vdrer,v-v.v/v:vtH;vuH=v?vvH@v[v]vwHxHyHzHAH1U2UBHCH^v_vDHEHFHGHHH3UIHJHKH4ULHMHNHOHPH`v{vQHRHSHTHUHVHWHXHYH|v}v~vawfrgrbwcwdwewfwZHgw0Hhwiw1Hjwkwlwmwnw2H3H4H5H6H7H8H9Howpw!H#H$H%H'H(H)H*H+H,H-H.H/H:H;Hqwrw=H?H@H[H]H5U^H6U_H`H7U{H|H}H~HaIbIcI8UdIeIswtwfIgIhIiIjI9UkI!UlImI#UnIoIpIqIrIsIuwvwtIuIvIwIxIyIzIAIBIwwxwywzwCIAwBwCwDwEwFwGwHwDIIwEIJwKwFILwMwNwOwPwQwRwSwTwUwVwWwXwYwGIZw0wHIIIJIKILIMINIOIPIQIRI1w2wSITIUIVIWIXIYIZI0I1I2I3I4I5I6I7I8I9I!I#I$I%I'I3w4w(I)I*I+I,I-I.I/I:I;I=I?I5w6w@I[I]I^I_I`I{I|I}I~IaJbJ7w8wcJdJeJfJgJ$UhJiJjJ%UkJlJmJnJ9w!woJpJqJrJsJtJ#w$wuJvJwJxJyJzJAJBJCJDJ%w'wEJFJGJHJIJ'UJJKJLJMJNJOJPJQJRJ(w)wSJTJUJVJWJXJYJZJ0J*w+w,w-w1J.w/whrir:w;w=w?w@w2J[w3J]w^w4J_w`w{w5J(U)U*U+U6J7J8J9J,U-U!J#J|w}w$J%J'J(J)J.U*J+J,J/U:U;U=U?U@U-J.J/J:J;J=J?J@J[U]U[J]J~wax^J_J`J{J|J^U}J~JaK_UbKcKdKeKfKgKhKiK`U{UjKkKbxcxlKmKnKoKpK|UqKrKsK}UtKuKvKwKxKyKzKAK~UaVBKCKdxexDKEKFKGKHKbVIKJKKKcVLKMKNKOKPKQKRKSKdVeVTKUKfxgxVKWKXKYKZKfV0K1K2KgV3K4K5K6K7K8K9K!KhViV#K$Khxix%K'K(K)K*KjV+K,K-KkV.K/K:K;K=K?K@K[KlVmV]K^Kjxkx_K`K{K|K}KnV~KaLbLoVpVcLdLeLfLgLhLiLjLqVrVkLlLlxmxmLnLoLpLqLsVrLsLtLtVuVuLvLwLxLvVwVxVyVzVAVBVCVDVEVFVGVHVIVJVKVLVMVNVOVPVQVRVSVTVUVVVWVXVYVZV0V1V2V3V4V5V6V7V8V9V!V#V$V%V'V(V)V*V+V,V-V.V/V:V;V=V?V@V[V]V^V_V`V{V|V}V~VaWbWcWdWeWfWgWhWiWjWkWlWmWnWoWpWqWrWsWtWuWvWwWxWyWzWAWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVWWWXWYWZW0W1W2W3W4W5W6W7W8W9W!W#W$W%W'W(W)W*W+W,W-W.W/W:W;W=W?W@W[W]W^W_W`W{W|W}W~WaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzXAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRX

123

124

125cdef CUresult cuCtxSetCurrent(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

126 return _driver._cuCtxSetCurrent(ctx) 2139 ctx2cMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzMAMBMCMe0DMEMFMGMHMIMXyYyZy0y1y2y3y4y5yEl}iFl6y~iGlHl7y8y9y!y#yJM$y%y'y(y)y*y+y,y-y.y/y:y;y=y?ySX@y[y]y^y_y`y{y|y}y~yazbzczdzezfzgzhzizIlJl@baj{d|dbjKlLlMlNlod}dIhJhKhLhOlPlQlRl[bcj~daedjSlTlUlVlpdbeMhNhOhPhWlXlYlejZljzfj0l1l2lgj3lhj4l5l6l7l]bijcedejj8l9l!l#lqdeeQhRhShTh$l%l'l(l^bkjfegelj)l*l+l,lrdheUhVhWhXh-l.l/l:l_bmjiejenj;l=l?l@lsdkeYhZh0h1h[l]l^l_l`bojlemepj`l{l|l}ltdne2h3h4h5h~lambmqjcmrjdmemfmsjgmtjhmimKMjmujkmvjlmmmLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM0M1Mf02M3M4M5M6M7M8M9M!M#M$M%M'M(M)M*Mg0+M,M-M.M/M:M;M=M?M@M[M]M^M_M`M{M|M}M~Mh0aNbNcNdNeNfNgNhNiNi0j0k0l0m0n0o0kzp0q0r0s0t0u0v0w0x0y0z0A0B0C0D0E0F0jNkNlNmNnNoNpNG0qN_p`prN{p|p~paqbq-qsNomwjtspmxjqmyjuscqdqOueqfqgqhqiqjq/itNyLnxzLoxALpxBLzjCL.qH0vsI0J0K0L0M0N0O0P0Q0gg8qhg/qDLqxELFLGLHLILJLKLLLMLNLOLPLrxsxtxuxvxwxxxgpyxzxAxBxQLCxrm:qRLDxSLExab9qbb;qR0S0TLFxULGxVLAjT0U0V0wsW0X0wNxNyNzNANBNY0@r[r]r^r_r`r{r^p|r}r~rasbscsdsesfsgshsisjskslsmsnsospsqs^g_gZ00010203040CNDN5060VPWL7080Tc0 UcENsmFN90!0#0$0GNHNIN%0JNKNLNMNNNONPN`gjp{g|gkp}g~gahjgbhchdhalTzBjCjtetmumDjEjFjQNGjHjIjUzVzWzXzYzZz0z1z2z3z4z5z6z7z8z9z!z#zRNIb:iue]d'0(0SN)0ehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhMsNsOsPsQsRsSsTsUsVsWsXsYsZs0s1s2s3s4s5s6s7s8s9s!s#s$s%s's(s)s*s+s`B,s-sbl_d{bHxTXjrkrIxkglgJxKxLxMxoqpqUXVX.sWX/sXXYXZX:s0X1X;s=s2X?s3X4X5X6X@s7X[s]s8X9X!X#X$X%X^s'X(X_s`s{sXL)X|s*X+X,X-X}s.X/X:X;X~s=X?X@Xat[X]Xbtctdt^Xet_Xftgt`X{X|X}Xhtit~XjtktaYbYcYltdYmteYntfYgYhYotiYptjYkYlYqtmYnYoYrtstpYttutvtqYcl+i,i%zTb*0'z3P+0,0{k|bPu-0|kTNQu.07hUN8h/09hVNRuWNib:0-i;0ud=0}k?0!hXNveYNvd@0}b[0#h]0weZN$h^0xe_0%h`0ye{0'h|0ze}0wd~0~ba1(hb1mgc1ngd1e1Zc0Nf1ogg11Npgh1i1qgj12Nrgk13Nxdl1m1sgn1o1)h4NAe5Nyd6Nacp1*hq1Be7N+hr1Ces1,h8NDe9N-ht1Ee!Nzd#Nbcu1.hv1Few1tgx1ug$N/hy1Ad%N0c'NBdz14PxtvmcclpCd.i~kA1UbB1dcGe(NC1D1E1F1G1edfd} )Ngdqq*Nxmym+Nzm,NAmBmCm-NDm.N/N:N;N=N?N@N[N]N^NEmFmGmHmytztAtBtCtDtEtFtGtImJmKmLmMmNmOmPmQmRmSmTmUmVmWmXmYmZm0m1m2m3m4m5m6m7m8m9m!m#m$m%m'm(m)m*m+m,m-m.m/m:m;m=m?m@m[m]m^m_m`m{m|mNx}mOx~manbncndnenfngnhninOAjnH1knI1;iJ1lnK1mnKjecrq_N`NLj)zMjNjOj*znnonpnqnHeIe=hsq+zHtrnsnPjtnItunQjfctq{N,zRj-zSjTjUj.zvnwnxnynJeKe?huq/zJtznAnVbLeMeVjvgwgxgDdNe@hygzgOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdjbkbYb, - . / ^hlbBgCgDgEg_hBnCn5cKdFgvqlrDnEnXjgcwqYjZj0j1j:zFnGnHnInRe|NSe`hxq;zJnKn2j{hZbLn=z|hKt}h~haiLt3j4j5j6jLd?zMdGgMnMtyq7j8j9jmbNdOdbiTeUeVe6cWeHgXeYemrci0bNn@zdi!j#jeiNt$j%j'j(jPd[zQdIgOnOt)j*jfigiZe0e1e2ehi3e4e5e6enbRdSd7e8e9eTdJg!e#ePnhczq+j,j-j.jQnRnSn$e%eii]zTnUnKgLgMgNgVnWnXnYnZnjiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncoc0npcAq;j=j?j@j^z1n2n3n4n.e/ekiBq_z5n6n3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jrclimi@e[eni7nRgSgTg8n]eZdUg9nVgWg!nsc]j^j_j`j#n$n%n^e_eoi'n(npiXgpb{jPtYgCqZg0g1gDqdlqirisi*cQt+c`e|jEqtiui)n*n}jtcFq}N~N~j`zakbkck{z+n,n-n.n{e|eviGq|zRt/n:n3b}e~edk2g3g4g0dafwi5g6gbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dqbrb6b; = ? @ Aisb7g8g9g!gBi;n=n.c8d#gHq?n@n[nfkucIqgkhkikjk}z]n^n_n`nefaOffCiSt~z{n|n}nkkvcJqbOlkaAmknkokbA~naobocogfcOhfDiTtcAUtdoeopktb9d!dEiifjfkf/clf$gmfnfqkFi7bfodAGirkskHiVttkukvkwk#deA$d%gKqWtxkykIiJiofpfqfrfKisftfufvfub%d'dwfxfyf(d'gzfAfgowcLqzkAkBkCkhoiojoBfCfLifAkolo(g)g*g+gmonooopoqoMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcroEcMqFkGkHkIkgAsotouovoKfLfNiXthAwoxo4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoGcJkKk/g:gLkNqOiPiQizoQfRfRiOqSiTiAoHcMkNkOkPkBoCoDoSfTfUiEoFoVi;gwbQkYt=gPq?g@g[gQqWiXiYiZi{cZt|cUfGoRq0i1iHodOeO}c?b.d/d0t1tIoRkIcSqfOiASkjATkUkVkkAJoKoLoMoVfWf2iTqUqgO2t3thOlA4tNoOoPoWkJcVqiOjOXkmAYkZk0knAQoRoSoToXfYf3iWqoA5tUoVoWo1kKcXqkOpA2kqA3k4k5krAXoYoZo0oZf0f4iYqsA6t1o2o3o6kLcZqlOtA7kuA8k9k!kvA4o5o6o7o1f2f5i0qwA7t8o9o!o#kMc1qmOxA$kyA%k'k(kzA#o$o%o'o3f4f6i2qAA8t(o)o*o)kNc3qnOBA*kCA+k,k-kDA+o,o-o.o5f6f7i4qEA9t/o:o;o.kOc5qoOpO/kFA:k;k=kGA=o?o@o[o7f8f8i!t#tHA$t]o^o_o?kPc6qqOrO@kIA[k]k^kJA`o{o|oar9f!f9i%t'tKA(t}o~osOtOL1uOM1vON1wOxOyOO1P1zOAOBOCODOEOFOQ1GOHOIOJOKOLOR1MONOOOS1POQOROSOTOT1UOVOWOXOYOZO0O1O2O3O4O5O6OU17OV18O9O!OW1X1#OY1Z1$O%O'O01(O)O*O+O11,O-OrY/O:O;O=O?O@O[O]O^O_O`O{O|O}O~OaPbPcPdPePnrfPgPhPiPjP^t_t`t{t|t}t~taubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzuAuBuCuDuEukPlPmPFuGuHu21nPoPpP31415161718191qPrPsPtP!1#1$1%1'1uPvPwPxPyP#f$forpr%f'f(f)f*fqr+f,f-frr.fsr/ftr:f;fur=fvr?fwr@fxr[fyrzr]f^f_f`f{fAr|fBr}f(1zP)1*1AP+1,1-1BPCP.1/1DPEP:1FPGPHPIPJP;1KP=1LPMPNPOPPPQPRP?1SPTP@1UP

127

128

129cdef CUresult cuCtxGetCurrent(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

130 return _driver._cuCtxGetCurrent(pctx) 2414 ctx2a rs)P*P+P,P-P.P/P:P;P=P?P@P[P]P^P_P`P{P|P}P~PaQbQcQdQeQfQgQhQiQjQkQlQmQHCICJCKCLCPxMCNCOCPCQCRCSCTCUCVCWCXCYCZC0C1CnQ2C3C4C5C6C#u7C8CoQpQ9C!C#C$C%C6 'C7 (C8 )C* *C#b+C$b,C%b-CQc.CqQ/C:C;C=C?C@C[C]C^C_C`C{C|C}CrQ$u%u~CaDsQMlbDNlcDdD}deDIhfDJhgDKhhDLhiDOljDPlkDlDmDnDtQ'u(uoDpDuQUlqDVlrDsDbetDMhuDNhvDOhwDPhxDWlyDXlzDADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQD)u*uRDSDTD!lUD#lVDWDeeXDQhYDRhZDSh0DTh1D$l2D%l3D4D5D6D7D+u,u8D9D!D+l#D,l$D%Dhe'DUh(DVh)DWh*DXh+D-l,D.l-D.D/D:D;D-u.u=D?D@D?l[D@l]D^Dke_DYh`DZh{D0h|D1h}D[l~D]laEbEcEdEeE/u:ufEgEhE|liE}ljEkEnelE2hmE3hnE4hoE5hpE~lqEamrEsEtEuEvEwExEyEzEAEBECEDEvQEEFEGEHEIEJEAlwQxQyQzQAQQxBQCQDQEQFQGQHQIQJQBlKQLQMQNQOQPQQQRQSQmpTQnpUQopVQppWQCbXQDbYQEbZQFb0Q1Q2Q3Q4Q5Q6Q7Q8Q9Q!Q#Q$Q%Q'Q(Q)Q*Q+Q,Q=i-Q.Q/Q:Q;Q=Q?Q@Q[Q]Qb ^Q_Q=b`Q{Q|Q}Q~QaRbRcRdReRfRgRhRiRjRKELEMENEkRlROEPEmRQERESETEnRUEVEoRpRqRrRsRtRuRvRwRxRyRzRARBRCRSATA^gDR_gERFRGRHRIRJRKRLRMRNRORsYxsUAVAWAXAYAZA0A1A2AtYys3A4Azs5A6A7A8A9A!A#A$A%AAs'A(A)A*A+A,A-A.A/ABs:A;A=A?A@A[A]A^A_ACs`A{A|A}A~AaBbBDscBdBeBfBgBhBiBjBkBlBmBnBEsoBpBFsqBrBsBtBuBvBwBxByBzBABBBCBGsDBEBFBHsGBHBIBJBKBIsLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB0B1B2B3B4B5B6B7B8B9B!B#B$BJs%B'B(BKs)BLs*B+B,B-B.B/B:B;B=B?B@B[B]B^B_BPRWLQRRRSRLAuYMA[1NATc0 UcTRsmURVRWRXRYRZR0R1R2R3R4R5R6R7R8R9Rel!RWEXEYEV #RW $RGCZE0E1E%R2E3E4E'R(R)R*R+R,R-R.R/R:R;R=R?R@R[R]R^R_R`Rue{R|R}R~RVcWcXcYcaSbScSdSeSfSgShSiSjSkSlSmSnSoSpSqSrSsStSuSvSwSxSySzSASBSCSDSESFSGSHSISJS{b.s/s:s;s=s?s@s[s]s^s_s`s{sXL|s}s~satbtctdtetftgthtitjtktltmtntotptqtrtstttutvtKSLSMS|bNSOSPSQSRSSSTSUSVSWSXS(zYSZS0S1S2S3S4S5S6S7S8S9S!S#S$S%S'S(S)S*S+S,S-S.S/S:S;S=S?S@S[S]S^S_S`S{S|S}S~SaTbTcTdTeTfTgThTiTjTkTlTmTnToTxtvmccCdpTqTrTsTtTuTvTwT} xTqqyTzTATBTCTDTETFTGTHTITHhJTKTLTMTNTOTPTQTRTSTTTUTVTWTXTYTZT0T1T2T3T4T5T6T7T8T9T!T#T$T%T'T(T)T*T+T,T-T.T/T:T;T=T?T@T[T]T^T_T`T{T|T}T~TaUbUcUdUeUfUgUhUiUjUkUlUmUnUoUpUqUrUsUtUuUvUwUxUyUzUAUBUCUDUEUFUGUHU5E6E7Erq8EIUJU9E!E;u=u#E$E%Eon'Epn(EKU)EIe*E=h+ELU,E-Ern.Esn/E:EMU;E=E?E@Etq[ENUOU]E^E?u@u_E`E{Ewn|Exn}EPU~EKeaF?hbFQUcFdFzneFAnfFgF[u]uhFiFwgjFxgkFlFNemF@hnFygoFzgpF^u_uPe`u{ubrcr|u}u~uGdavHdbvqFcvrFXbdv4cevsFfvIdgvJdhvivjvtF, uF- vF. wF/ xF^hyFlbzFBgAFCgkvDglvEgBF_hCFBnDFCnEF5cFFKdGFFgHFvqIFlrJFDnKFLFMFNFwqOFPFmvnvQFRFSFGnTFHnUFRUVFSUSeWF`hXFTUYFJnZFKn0F1F2F3FLn4FUU5F6Fovpv7F8F9F4j!F5j#FVU$FWUMd%FGg'FXU(F)F7j*F8j+F,F-Fqvrv.F/FUe:FVe;F=FWe?FHg@FXe[FYe]FsvtvuvNnvv^FwvxvyvzvAvBv%jCv'jDv_FEv`FQdFvIgGv{FHv)jIv*jJvKvLvZeMv0eNv1eOv2ePvQv3eRv4eSv5eTv6eUv|FVvWv}F8e~F9eaGTdbGJgcG!edG#eeGfGgGzqhGiGXvYvjGkGRnlGSnmGnG%eoGiipGqGTnrGUnsGKgtGLguGMgvGNgwGVnxGWnyGXnzGYnAGZnBGCGDGOgEGFGZv0vGGHGIG(eJG)eKGLG7cMG+eNGOG,ePG-eQGRG1v2vSGTGkcUGlcVGobWGmcXGncYGocZG0G1GAq2G3G3v4v4G5G6G2n7G3n8GYU9G/e!Gki#GZU$G5n%G6n'G3 (G1b5v2b6vqc)G#c*G$c+G%c,G'c-G: .G(c7v)c8vXd/G:e:G;e;GYd=G=e?G?e@G[G]Gli^G_G9v!v`G{G|GSg}GTg~G0UaHZdbHUgcHdHVgeHWgfHgHhHiH#v$vjHkH$nlH%nmHnH_eoHoipH'nqH(nrH%v'v(v{j)vsH*v+vdrer,v-v.vqi/vri:vtH;vuH+c=v`e?vvH@vti[vui]v)nwHxHyHzHFqAH1U2UBHCH^v_vDHEHFH,nGH-nHH3UIH|eJHviKH4ULHMH/nNH:nOHPH`v{vQHRH3gSH4gTHUHafVHwiWH5gXH6gYH|v}vcf~vawfrgrbwcwdw4dew5dfwZHgw0H5bhw-ciw1Hjw6dkw7dlwmwnw2H; 3H= 4H? 5H@ 6HAi7Hsb8H7g9H8gow9gpw!g!HBi#H;n$H=n%H.c'H8d(H#g)HHq*H?n+H@n,H-H.H/HIq:H;Hqwrw=H?H@H^n[H_n]H5U^H6Uff_HCi`H7U{H{n|H|n}H~HaIbIJqcI8UdIeIswtwfIgIhIaoiIbojI9UkI!UhflIDimI#UnIoIdopIeoqIrIsIuwvwtIuIjfvIkfwIxIlfyI$gzImfAInfBIwwxwywfozwCIAwBwCwDwEwFwukGwvkHwDIIwEI$dJw%gKwFILwxkMwykNwOwPwofQwpfRwqfSwrfTwUwsfVwtfWwufXwvfYwGIZw0wHIxfIIyfJI(dKI'gLIzfMIAfNIOIPILqQIRI1w2wSITIioUIjoVIWICfXILiYIZIko0Ilo1I(g2I)g3I*g4I+g5Imo6Ino7Ioo8Ipo9Iqo!I#I$I,g%I'I3w4w(I)I*IEf+IFf,I-I:c.IHf/I:IIf;IJf=I?I5w6w@I[Izc]IAc^Ivb_IBc`ICc{IDc|I}I~IMqaJbJ7w8wcJdJeJtofJuogJ$UhJLfiJNijJ%UkJwolJxomJ4 nJ8b9w9b!wFcoJ@cpJ[cqJ]crJ^csJ[ tJ_c#w`c$w,duJMfvJNfwJ-dxJOfyJPfzJAJBJJkCJDJ%w'wEJFJGJPiHJQiIJ'UJJRfKJRiLJMJSiNJTiOJPJQJRJ(w)wSJTJCoUJDoVJWJTfXJUiYJEoZJFo0J*w+w,wQk-w1J.w/whrir:w;w=wXi?wYi@w2J[w3J|c]wUf^w4J_w0i`w1i{wHo5J(U)U*U+U6J7J8JSq9J,U-U!J#J|w}w$J%J'JKo(JLo)J.U*JWf+J2i,J/U:U;U=U?U@U-J.JNo/JOo:J;J=J?JVq@J[U]U[J]J~wax^J_J`JRo{JSo|J^U}JYf~J3iaK_UbKcKUodKVoeKfKgKhKXqiK`U{UjKkKbxcxlKmKnKYooKZopK|UqK0frK4isK}UtKuK1ovK2owKxKyKzKZqAK~UaVBKCKdxexDKEKFK5oGK6oHKbVIK2fJK5iKKcVLKMK8oNK9oOKPKQKRK1qSKdVeVTKUKfxgxVKWKXK$oYK%oZKfV0K4f1K6i2KgV3K4K(o5K)o6K7K8K9K3q!KhViV#K$Khxix%K'K(K,o)K-o*KjV+K6f,K7i-KkV.K/K/o:K:o;K=K?K@K5q[KlVmV]K^Kjxkx_K`K{K?o|K@o}KnV~K8faL8ibLoVpVcLdL]oeL^ofLgLhLiL6qjLqVrVkLlLlxmxmLnLoL{opL|oqLsVrL!fsL9itLtVuVuLvL}owL~oxLvVwV)txVyVzVAVBVCVDVEVFVGVHVIVJVKVLVMVNVOVPVQVRVSVTVUVVVWVXVYVZV0V1V2V3V4V5V6V7V8V9V!V#V*tvY+t|i$V%V'V(V)V*V+V,V-V.V/V:V;V=V,t-t.t/t:t;t?V=t?t@t[twY]t@V[V]V^V_V`V{V|V}V~VaWbWcWdWeWfWgWhWiWjWkWlWCrmWnWoWpWqWrWsWtWuWvWwWxWyWzWAWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVWWWXWYWZW0W1W2W3W4W5W6W7W8W9W!W#W$W%W'W(W)W*W+W,W-W.W/W:W;W=W?W@W[W]W^W_W`W{W|W}W~WaXbXcXdXeXfXgXhXiX#f$f%f'f(f)f*f+f,f-f.f/f:f;f=f?f@f[f]f^f_f`f{f|f}fjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzXAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRX

131

132

133cdef CUresult cuCtxGetDevice(CUdevice* device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

134 return _driver._cuCtxGetDevice(device) 1555 ctx2a rsJbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J PAQA!q]1;rMuRANuEl}iFl~iGlHl#qhd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQc$q%q'q(q)q*q$i_kIlJl@baj{d|dbjod}dIhJhKhLhQlRl[bcj~daedjpdbeMhNhOhPhYlejZlfj0l1l2lgj3lhj4l5l6l7l]bijcedejjqdeeQhRhShTh'l(l^bkjfegeljrdheUhVhWhXh/l:l_bmjiejenjsdkeYhZh0h1h^l_l`bojlemepjtdne2h3h4h5hbmqjcmrjdmemfmsjgmtjhmimjmujkmvjlmmm`k+q;dcdWPXPYPZP0P1PCbDbEbFb/b:b'b~ =d@iLbMb?d[iK N ,qagX ^ _ (b;bO L A F B b x 9 y z C { D w P Q R ^1E Y Z Gb)b*bddScU _p`p_1{p|p~paqbq-qomwjtspmxjDrqmEryjuscqdqOueqfqgqhqiqjq/inxoxpxzj.q/qqxrxsxtxuxvxwxxxgpyxzxAxBxCx:qDxEx;qFxGxAjRxSxTxUxVxWxSATA^g_gYLXxsYxsUAVAWAXAYAZA0A1A2AtYys3A4Azs5A6A7A8A9A!A#A$A%AAs'A(A)A*A+A,A-A.A/ABs:A;A=A?A@A[A]A^A_ACs`A{A|A}A~AaBbBDscBdBeBfBgBhBiBjBkBlBmBnBEsoBpBFsqBrBsBtBuBvBwBxByBzBABBBCBGsDBEBFBHsGBHBIBJBKBIsLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB0B1B2B3B4B5B6B7B8B9B!B#B$BJs%B'B(BKs)BLs*B+B,B-B.B/B:B;B=B?B@B[B]B^B_BWLLAuYMANATc0 UcZLsm0Lflglhliljlkl` llmlnlolpl]iEhRcIb:iue]d`12P^iehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDh{1MsNsOs|1PsQsRsSsTsUsVsWsXsYsZs0s1s2s3s4s5s6s7s8s9s!s#s$s%s's(s)s*s+s`B,s-sbl_d{bHxTXjrkrIxUXVX.sWX/sXXYXZX:s0X1X;s=s2X?s3X4X5X6X@s7X[s]s8X9X!X#X$X%X^s'X(X_s`s{sXL)X|s*X+X,X-X}s.X/X:X;X~s=X?X@Xat[X]Xbtctdt^Xet_Xftgt`X{X|X}Xhtit~XjtktaYbYcYltdYmteYntfYgYhYotiYptjYkYlYqtmYnYoYrtstpYttutvtqYcl+i,iTb}1{k|bPu|kQu7h8h9hRuib-iud}k(z!hvevd}b#hwe$hxe%hye'hzewd~b(hmgng{BZc|Bog}Bpg~BqgaCrgbCxdcCsgdC)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBdxtvmcclpCd.i~kUbdcGewm:h;h5Pqlrledfd} 6Pgdqq7PxmxYym=qzm?qAmyYBmzYCmM DmHh@q[q]q^q_q`q{q|q}q~qEmFmGmHmytztAtBtCtDtEtFtGteCImfCJmgCKmhCLmiCMmjCNmSuOmTuPmUuQmVuRmWuSmXuTmYuUmZuVm0uWm1uXm2uYm3uZm4u0m5u1m6u2m7u3m8u4m9u5m~16ma27mkC8mlC9mmC!mnC#moC$mpC%mqC'mrC(msC)mtC*muC+mvC,mwC-mxC.myC/mzC:mAC;mBC=mCC?mDC@mEC[mb2]mAY^mBY_mCY`mDY{mEY|mFYNxGY}mHYOxIY~mJYanKYbnLYcnMYdnNYenOYfnPYgnhnmnecLjOjqnHeIe=hsqtnunfcRjUjynJeKe?huqVbLeMeVjvgwgxgDdNe@hygzgOe' Ed3cQeWbXb4cAgjbkbYb, - . / ^hlbBgEg5cKdFgEngcYj1jInReSe`hxq2jZb|hai6jLdMdGgMn9jmbNdOdbiTeUeVe6cWeHgXeYemr0bdiei(jPdQdIgOnnbRdSd7e8e9eTdJg!e#ePnhc+j.j$e%eiijiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncoc0npc;j@j4n.e/ekiBq3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jrclimi@e[eni7nRgSgTg8n]eZdUg9nVgWg!nsc]j`j^e_eoipipbYg1gsi*c+c`e|j*ntc~jck.n{e|eviGq3b}e~edk2g3g4g0dafwi5g6gbf( 1d2ddf4b5b-cyiqbrb6b; = ? @ Aisb7g!g.c8d#g[nucgkjk`nefffCiSt}nvclkokcogfhfDiTtpktb9d!dEiifjfkf/clf$gmfnfqk7bGiHiwk#d$d%gKqub%d'dwfxfyf(d'gzfAfgowczkCkBfCfLiMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcroEcFkIkvoKfLfNiXt4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoGcJkKk/g:gLkNqOiPiQizoQfRfRiOqSiTiAoHcMkPkSfTfUiViwb=g[gZi{c|cUfGo0t1tIoIcSkVkMoVfWf2iTqUq2t3tPoJcXk0kToXfYf3iWqWoKc2k5k0oZf0f4iYq3oLc7k!k7o1f2f5i0q!oMc$k(k'o3f4f6i2q*oNc*k-k.o5f6f7i4q;oOc/k=k[o7f8f8i!t#t_oPc@k^kar9f!f9i%t't8P9P)tc2!P#P$P*tvY+t|i,t-t.t/t:t;td2=t?t@t[twY]t%P!urYe2YxZx0x1x2x3xCr4x5x6x7x8x9x!x#x$xsl%xnrFr'xFh(x^t_t`t{t|t}t~taubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzuAuBuCuDuEuFuGuHuf2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2A2B2C2#f$forpr%f'f(f)f*fqr+f,f-frr.fsr/ftr:f;fur=fvr?fwr@fxr[fyrzr]f^f_f`f{fAr|fBr}fD2E2

135

136

137cdef CUresult cuCtxGetFlags(unsigned int* flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

138 return _driver._cuCtxGetFlags(flags)

139

140

141cdef CUresult cuCtxSetFlags(unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

142 return _driver._cuCtxSetFlags(flags)

143

144

145cdef CUresult cuCtxGetId(CUcontext ctx, unsigned long long* ctxId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

146 return _driver._cuCtxGetId(ctx, ctxId)

147

148

149cdef CUresult cuCtxSynchronize() except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

150 return _driver._cuCtxSynchronize()

151

152

153cdef CUresult cuCtxSetLimit(CUlimit limit, size_t value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

154 return _driver._cuCtxSetLimit(limit, value)

155

156

157cdef CUresult cuCtxGetLimit(size_t* pvalue, CUlimit limit) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

158 return _driver._cuCtxGetLimit(pvalue, limit)

159

160

161cdef CUresult cuCtxGetCacheConfig(CUfunc_cache* pconfig) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

162 return _driver._cuCtxGetCacheConfig(pconfig)

163

164

165cdef CUresult cuCtxSetCacheConfig(CUfunc_cache config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

166 return _driver._cuCtxSetCacheConfig(config)

167

168

169cdef CUresult cuCtxGetApiVersion(CUcontext ctx, unsigned int* version) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

170 return _driver._cuCtxGetApiVersion(ctx, version)

171

172

173cdef CUresult cuCtxGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

174 return _driver._cuCtxGetStreamPriorityRange(leastPriority, greatestPriority) 393 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQccd/b:bLbMbK N X ^ _ ;bO L A F B b +b,b-bkdldmdx 9 y z C { D w P Q R NbObPb! # $ E Y Z Gb)b*bddScU dg`dtlulndvlwlDrEregfgqprpsptpup/i% ] bp]g!i#icpdpepfpxl1L2LigQbabbb+ ~fRbSbcbdbebfbgbhbRxSxTxUxVxWxXxTc0 Ucflglhliljlkl` llmlnlolpl]iEhRc`gjp{g|gkp}g~gahjgbhchdhal)xHbV W QY3L_iIb:iue]d^i_d{bGrHrvpIrwpJrKrxpypLrMrNrzpOrApBpCpDpEpFpGpHpIpPrJpKpLpMpQrNpOpRrSrTrUrPpVrQpWrXrRpSpYrZr0rTp1rUpVpWpXpYpZp0p1p2p2r3p4p5p6p3r7p8p4r5r6r7r9p8r!p9r!r#p$p#r$r%r%p'r'p(p)p*p+p,p-p.p/p(r:p;p=p?p)r@p[p*r+rTbiblpUbqlrlM ;iHtItJtyqpiXgpb{jPtYgCqZg0g1gDqdlqirisi*cQt+c`e|jEqtiuiRtUtVi;gwbQkYt=gPq?g@g[gQqWiXiYiZi{cZt|cUfGoRq0i1i.d/d4t5t6t7t8t9t$t(tYxZx0x1x2x3xCr4x5x6x7x8x9x!x#x$xsl%xnrFr'xFh(x

175

176

177cdef CUresult cuCtxResetPersistingL2Cache() except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

178 return _driver._cuCtxResetPersistingL2Cache()

179

180

181cdef CUresult cuCtxGetExecAffinity(CUexecAffinityParam* pExecAffinity, CUexecAffinityType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

182 return _driver._cuCtxGetExecAffinity(pExecAffinity, type)

183

184

185cdef CUresult cuCtxRecordEvent(CUcontext hCtx, CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

186 return _driver._cuCtxRecordEvent(hCtx, hEvent)

187

188

189cdef CUresult cuCtxWaitEvent(CUcontext hCtx, CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

190 return _driver._cuCtxWaitEvent(hCtx, hEvent)

191

192

193cdef CUresult cuCtxAttach(CUcontext* pctx, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

194 return _driver._cuCtxAttach(pctx, flags)

195

196

197cdef CUresult cuCtxDetach(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

198 return _driver._cuCtxDetach(ctx)

199

200

201cdef CUresult cuCtxGetSharedMemConfig(CUsharedconfig* pConfig) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

202 return _driver._cuCtxGetSharedMemConfig(pConfig)

203

204

205cdef CUresult cuCtxSetSharedMemConfig(CUsharedconfig config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

206 return _driver._cuCtxSetSharedMemConfig(config)

207

208

209cdef CUresult cuModuleLoad(CUmodule* module, const char* fname) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

210 return _driver._cuModuleLoad(module, fname)

211

212

213cdef CUresult cuModuleLoadData(CUmodule* module, const void* image) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

214 return _driver._cuModuleLoadData(module, image) 8 ctx2@d[d%i'i(ibg)i*i

215

216

217cdef CUresult cuModuleLoadDataEx(CUmodule* module, const void* image, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

218 return _driver._cuModuleLoadDataEx(module, image, numOptions, options, optionValues) 1 ctx2F2

219

220

221cdef CUresult cuModuleLoadFatBinary(CUmodule* module, const void* fatCubin) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

222 return _driver._cuModuleLoadFatBinary(module, fatCubin)

223

224

225cdef CUresult cuModuleUnload(CUmodule hmod) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

226 return _driver._cuModuleUnload(hmod) 8 ctx2@d[d%i'i(ibg)i*i

227

228

229cdef CUresult cuModuleGetLoadingMode(CUmoduleLoadingMode* mode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

230 return _driver._cuModuleGetLoadingMode(mode)

231

232

233cdef CUresult cuModuleGetFunction(CUfunction* hfunc, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

234 return _driver._cuModuleGetFunction(hfunc, hmod, name) 8 ctx2@d[d%i'i(ibg)i*i

235

236

237cdef CUresult cuModuleGetFunctionCount(unsigned int* count, CUmodule mod) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

238 return _driver._cuModuleGetFunctionCount(count, mod)

239

240

241cdef CUresult cuModuleEnumerateFunctions(CUfunction* functions, unsigned int numFunctions, CUmodule mod) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

242 return _driver._cuModuleEnumerateFunctions(functions, numFunctions, mod)

243

244

245cdef CUresult cuModuleGetGlobal(CUdeviceptr* dptr, size_t* bytes, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

246 return _driver._cuModuleGetGlobal_v2(dptr, bytes, hmod, name) 1 ctx2bg

247

248

249cdef CUresult cuLinkCreate(unsigned int numOptions, CUjit_option* options, void** optionValues, CUlinkState* stateOut) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

250 return _driver._cuLinkCreate_v2(numOptions, options, optionValues, stateOut)

251

252

253cdef CUresult cuLinkAddData(CUlinkState state, CUjitInputType type, void* data, size_t size, const char* name, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

254 return _driver._cuLinkAddData_v2(state, type, data, size, name, numOptions, options, optionValues)

255

256

257cdef CUresult cuLinkAddFile(CUlinkState state, CUjitInputType type, const char* path, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

258 return _driver._cuLinkAddFile_v2(state, type, path, numOptions, options, optionValues)

259

260

261cdef CUresult cuLinkComplete(CUlinkState state, void** cubinOut, size_t* sizeOut) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

262 return _driver._cuLinkComplete(state, cubinOut, sizeOut)

263

264

265cdef CUresult cuLinkDestroy(CUlinkState state) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

266 return _driver._cuLinkDestroy(state)

267

268

269cdef CUresult cuModuleGetTexRef(CUtexref* pTexRef, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

270 return _driver._cuModuleGetTexRef(pTexRef, hmod, name)

271

272

273cdef CUresult cuModuleGetSurfRef(CUsurfref* pSurfRef, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

274 return _driver._cuModuleGetSurfRef(pSurfRef, hmod, name)

275

276

277cdef CUresult cuLibraryLoadData(CUlibrary* library, const void* code, CUjit_option* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, CUlibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

278 return _driver._cuLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) 429 ctx2S T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J 2 ybzbAb!bBb$i_k@bod[bpd]bqd^brd_bsd`btd;dCbDbEbFb'bK N ,qagX ^ _ (bO L A F B b x 9 y z C { D w P Q R E Y Z Gb)b*bddScU % ] 0 ` RctetmumIb]d^iehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhxmym=qzm?qAmBmCmM DmHh@q[q]q^q_q`q{q|q}q~qEmFmGmRYHmSYG2ImJmKmLmMmNmOmPmQmRmSmTmUmVmWmXmYmZm0m1m2m3m4m5m6m7m8m9m!m#m$m%m'm(m)m*m+m,m-m.m/m:m;m=m?m@m[m]m^m_m`m{m|mNx}mOx~manbncndnenfngnhnecqnHesqtnfcynJeuqVbDd' QeWbAgjbkbYb, - . / lb5cgcInRexqZb6jLdMnmb6c0b(jPdOnnbhc$ejiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncocpc4n.eBq3 : [jrclimi@e[eni7nRgSgTg8n]eZdUg9nVgWgsc^epbsi*c|jtc.n{eGq3b0d( df4bqbrb6b; = ? @ sb.cuc`nefvccogftb/c7bwk#dubwcBfMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcEcvoKf4 [ GczoQfHcSfwbZi{cIcMoVfTqUqJcToXfWqKc0oZfYqLc7o1f0qMc'o3f2qNc.o5f4qOc[o7fPcar9f|i!u

279

280

281cdef CUresult cuLibraryLoadFromFile(CUlibrary* library, const char* fileName, CUjit_option* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, CUlibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

282 return _driver._cuLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) 4 ctx2TYUYVYWY

283

284

285cdef CUresult cuLibraryUnload(CUlibrary library) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

286 return _driver._cuLibraryUnload(library)

287

288

289cdef CUresult cuLibraryGetKernel(CUkernel* pKernel, CUlibrary library, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

290 return _driver._cuLibraryGetKernel(pKernel, library, name) 401 ctx2S T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J 2 ybzbAb!bBb$i_k@bod[bpd]bqd^brd_bsd`btd;dCbDbEbFb'bK N ,qagX ^ _ (bO L A F B b x 9 y z C { D w P Q R E Y Z Gb)b*bddScU % ] 0 ` RctetmumIb]d^iehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhxmym=qzm?qAmBmCmM DmHh@q[q]q^q_q`q{q|q}q~qEmTYFmUYGmRYHmVYWYSYImJmKmLmMmNmOmPmQmRmSmTmUmVmWmXmYmZm0m1m2m3m4m5m6m7m8m9m!m#m$m%m'm(m)m*m+m,m-m.m/m:m;m=m?m@m[m]m^m_m`m{m|mNx}mOx~manbncndnenfngnhnecqnHetnfcynJeVbDd' QeWbjbkbYb, - . / lb5cgcInReZb6jLdmb6c0b(jPdnbhc$ejiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncocpc4n.e3 : rc8n]esc^epbsi*ctc.n{e3b0d( df4bqbrb6b; = ? @ sb.cuc`nefvccogftb/c7bwk#dubwcBfMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcEcvoKf4 [ GczoQfHcSfwbZi{cIcMoVfJcToXfKc0oZfLc7o1fMc'o3fNc.o5fOc[o7fPcar9f|i!u

291

292

293cdef CUresult cuLibraryGetKernelCount(unsigned int* count, CUlibrary lib) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

294 return _driver._cuLibraryGetKernelCount(count, lib)

295

296

297cdef CUresult cuLibraryEnumerateKernels(CUkernel* kernels, unsigned int numKernels, CUlibrary lib) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

298 return _driver._cuLibraryEnumerateKernels(kernels, numKernels, lib)

299

300

301cdef CUresult cuLibraryGetModule(CUmodule* pMod, CUlibrary library) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

302 return _driver._cuLibraryGetModule(pMod, library)

303

304

305cdef CUresult cuKernelGetFunction(CUfunction* pFunc, CUkernel kernel) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

306 return _driver._cuKernelGetFunction(pFunc, kernel)

307

308

309cdef CUresult cuKernelGetLibrary(CUlibrary* pLib, CUkernel kernel) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

310 return _driver._cuKernelGetLibrary(pLib, kernel)

311

312

313cdef CUresult cuLibraryGetGlobal(CUdeviceptr* dptr, size_t* bytes, CUlibrary library, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

314 return _driver._cuLibraryGetGlobal(dptr, bytes, library, name)

315

316

317cdef CUresult cuLibraryGetManaged(CUdeviceptr* dptr, size_t* bytes, CUlibrary library, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

318 return _driver._cuLibraryGetManaged(dptr, bytes, library, name)

319

320

321cdef CUresult cuLibraryGetUnifiedFunction(void** fptr, CUlibrary library, const char* symbol) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

322 return _driver._cuLibraryGetUnifiedFunction(fptr, library, symbol)

323

324

325cdef CUresult cuKernelGetAttribute(int* pi, CUfunction_attribute attrib, CUkernel kernel, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

326 return _driver._cuKernelGetAttribute(pi, attrib, kernel, dev) 42 ctx2,qagX xY=q?qyYzYSuTuUuVuWuXuYuZu0u1u2u3u4u5u6u7u8u9uAYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPY

327

328

329cdef CUresult cuKernelSetAttribute(CUfunction_attribute attrib, int val, CUkernel kernel, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

330 return _driver._cuKernelSetAttribute(attrib, val, kernel, dev)

331

332

333cdef CUresult cuKernelSetCacheConfig(CUkernel kernel, CUfunc_cache config, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

334 return _driver._cuKernelSetCacheConfig(kernel, config, dev)

335

336

337cdef CUresult cuKernelGetName(const char** name, CUkernel hfunc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

338 return _driver._cuKernelGetName(name, hfunc) 1 ctx2H2

339

340

341cdef CUresult cuKernelGetParamInfo(CUkernel kernel, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

342 return _driver._cuKernelGetParamInfo(kernel, paramIndex, paramOffset, paramSize) 13 ctx2M Hh@q[q]q^q_q`q{q|q}q~qI2

343

344

345cdef CUresult cuMemGetInfo(size_t* free, size_t* total) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

346 return _driver._cuMemGetInfo_v2(free, total)

347

348

349cdef CUresult cuMemAlloc(CUdeviceptr* dptr, size_t bytesize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

350 return _driver._cuMemAlloc_v2(dptr, bytesize) 61 ctx2/i*xXY| YYZY0Y1Y2Y3Y4Y5Y6Y7Y8Y@d[dbl_d{bHxIxGrHrvpIrwpJrKrxpypLrMrNrzpOrApBpCpDpEpFpGpHpIpPrJpKpLpMpQrNpOpRrSrclvmcclpqlrl

351

352

353cdef CUresult cuMemAllocPitch(CUdeviceptr* dptr, size_t* pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

354 return _driver._cuMemAllocPitch_v2(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes)

355

356

357cdef CUresult cuMemFree(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

358 return _driver._cuMemFree_v2(dptr) 140 ctx2~ x 9 y z C { D w P Q R KELEMENE-qOEQESE,rUEVE/ireQbabbb+ RbSbsecbdbebfbgbhbhp*x-rXY| YYZY0Y1Y2Y3Y4Y5Y6Y7YIb:iue8Y@d[dbl_d{bHxkrIxJxKxGrHrvpIrwpJrKrxpypLrMrNrzpOrApBpCpDpEpFpGpHpIpPrJpKpLpMpQrNpOpRrSr6r7r9p8r!p9r!r#p$p#r$r%r%p'r'p(p)p*p+p,p-p.p/p(r:p;p=p?p)r@p[p*r+rcl{kvmcclpqlrl

359

360

361cdef CUresult cuMemGetAddressRange(CUdeviceptr* pbase, size_t* psize, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

362 return _driver._cuMemGetAddressRange_v2(pbase, psize, dptr)

363

364

365cdef CUresult cuMemAllocHost(void** pp, size_t bytesize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

366 return _driver._cuMemAllocHost_v2(pp, bytesize) 115 ctx2S 1 c d e f g h i j k l m n o p q r s t u v G H I J O L A F B b =bE Y Z % ] 0 ` HbV W IbehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhbl_d{bjrLxMxTrUrPpVrQpWrXrRpSpYrZr0rTp1rUpVpWpXpYpZp0p1p2p2r3p4p5p6p3r7p8p4r5rclM

367

368

369cdef CUresult cuMemFreeHost(void* p) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

370 return _driver._cuMemFreeHost(p) 116 ctx2S 1 c d e f g h i j k l m n o p q r s t u v G H I J O L A F B b =bE Y Z 9Y!Y0 ` HbV W IbehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhbl_d{bjrLxMxTrUrPpVrQpWrXrRpSpYrZr0rTp1rUpVpWpXpYpZp0p1p2p2r3p4p5p6p3r7p8p4r5rclccM

371

372

373cdef CUresult cuMemHostAlloc(void** pp, size_t bytesize, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

374 return _driver._cuMemHostAlloc(pp, bytesize, Flags) 2 ctx29Y!Y

375

376

377cdef CUresult cuMemHostGetDevicePointer(CUdeviceptr* pdptr, void* p, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

378 return _driver._cuMemHostGetDevicePointer_v2(pdptr, p, Flags)

379

380

381cdef CUresult cuMemHostGetFlags(unsigned int* pFlags, void* p) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

382 return _driver._cuMemHostGetFlags(pFlags, p)

383

384

385cdef CUresult cuMemAllocManaged(CUdeviceptr* dptr, size_t bytesize, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

386 return _driver._cuMemAllocManaged(dptr, bytesize, flags) 84 ctx2x 9 y z C { D w P Q R {p|p~paq-qompmqm,rcqdq% ] igQbabbb+ ~fRbSbcbdbebfbgbhbhp-rIb:iuebl_d{bkrJxKx6r7r9p8r!p9r!r#p$p#r$r%r%p'r'p(p)p*p+p,p-p.p/p(r:p;p=p?p)r@p[p*r+rcl{k

387

388

389cdef CUresult cuDeviceRegisterAsyncNotification(CUdevice device, CUasyncCallback callbackFunc, void* userData, CUasyncCallbackHandle* callback) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

390 return _driver._cuDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback)

391

392

393cdef CUresult cuDeviceUnregisterAsyncNotification(CUdevice device, CUasyncCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

394 return _driver._cuDeviceUnregisterAsyncNotification(device, callback)

395

396

397cdef CUresult cuDeviceGetByPCIBusId(CUdevice* dev, const char* pciBusId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

398 return _driver._cuDeviceGetByPCIBusId(dev, pciBusId)

399

400

401cdef CUresult cuDeviceGetPCIBusId(char* pciBusId, int len, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

402 return _driver._cuDeviceGetPCIBusId(pciBusId, len, dev)

403

404

405cdef CUresult cuIpcGetEventHandle(CUipcEventHandle* pHandle, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

406 return _driver._cuIpcGetEventHandle(pHandle, event) 14 ctx2% ] bp]g!i#icpdpepfpxl;i.d/d

407

408

409cdef CUresult cuIpcOpenEventHandle(CUevent* phEvent, CUipcEventHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

410 return _driver._cuIpcOpenEventHandle(phEvent, handle)

411

412

413cdef CUresult cuIpcGetMemHandle(CUipcMemHandle* pHandle, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

414 return _driver._cuIpcGetMemHandle(pHandle, dptr)

415

416

417cdef CUresult cuIpcOpenMemHandle(CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

418 return _driver._cuIpcOpenMemHandle_v2(pdptr, handle, Flags)

419

420

421cdef CUresult cuIpcCloseMemHandle(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

422 return _driver._cuIpcCloseMemHandle(dptr)

423

424

425cdef CUresult cuMemHostRegister(void* p, size_t bytesize, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

426 return _driver._cuMemHostRegister_v2(p, bytesize, Flags) 2 ctx2oqpq

427

428

429cdef CUresult cuMemHostUnregister(void* p) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

430 return _driver._cuMemHostUnregister(p) 2 ctx2oqpq

431

432

433cdef CUresult cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

434 return _driver._cuMemcpy(dst, src, ByteCount)

435

436

437cdef CUresult cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

438 return _driver._cuMemcpyPeer(dstDevice, dstContext, srcDevice, srcContext, ByteCount)

439

440

441cdef CUresult cuMemcpyHtoD(CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

442 return _driver._cuMemcpyHtoD_v2(dstDevice, srcHost, ByteCount) 2 ctx2*x|

443

444

445cdef CUresult cuMemcpyDtoH(void* dstHost, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

446 return _driver._cuMemcpyDtoH_v2(dstHost, srcDevice, ByteCount) 8 ctx26 7 8 * K N *x|

447

448

449cdef CUresult cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

450 return _driver._cuMemcpyDtoD_v2(dstDevice, srcDevice, ByteCount)

451

452

453cdef CUresult cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

454 return _driver._cuMemcpyDtoA_v2(dstArray, dstOffset, srcDevice, ByteCount)

455

456

457cdef CUresult cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

458 return _driver._cuMemcpyAtoD_v2(dstDevice, srcArray, srcOffset, ByteCount)

459

460

461cdef CUresult cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

462 return _driver._cuMemcpyHtoA_v2(dstArray, dstOffset, srcHost, ByteCount)

463

464

465cdef CUresult cuMemcpyAtoH(void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

466 return _driver._cuMemcpyAtoH_v2(dstHost, srcArray, srcOffset, ByteCount)

467

468

469cdef CUresult cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

470 return _driver._cuMemcpyAtoA_v2(dstArray, dstOffset, srcArray, srcOffset, ByteCount)

471

472

473cdef CUresult cuMemcpy2D(const CUDA_MEMCPY2D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

474 return _driver._cuMemcpy2D_v2(pCopy)

475

476

477cdef CUresult cuMemcpy2DUnaligned(const CUDA_MEMCPY2D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

478 return _driver._cuMemcpy2DUnaligned_v2(pCopy)

479

480

481cdef CUresult cuMemcpy3D(const CUDA_MEMCPY3D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

482 return _driver._cuMemcpy3D_v2(pCopy)

483

484

485cdef CUresult cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

486 return _driver._cuMemcpy3DPeer(pCopy)

487

488

489cdef CUresult cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

490 return _driver._cuMemcpyAsync(dst, src, ByteCount, hStream) 39 ctx2x 9 y z C { D w P Q R % ] igQbabbb+ ~fRbSbcbdbebfbgbhbHbV W Ib:iue_d{bTbibUbM

491

492

493cdef CUresult cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

494 return _driver._cuMemcpyPeerAsync(dstDevice, dstContext, srcDevice, srcContext, ByteCount, hStream)

495

496

497cdef CUresult cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

498 return _driver._cuMemcpyHtoDAsync_v2(dstDevice, srcHost, ByteCount, hStream)

499

500

501cdef CUresult cuMemcpyDtoHAsync(void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

502 return _driver._cuMemcpyDtoHAsync_v2(dstHost, srcDevice, ByteCount, hStream) 3 ctx2@d[dbg

503

504

505cdef CUresult cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

506 return _driver._cuMemcpyDtoDAsync_v2(dstDevice, srcDevice, ByteCount, hStream)

507

508

509cdef CUresult cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

510 return _driver._cuMemcpyHtoAAsync_v2(dstArray, dstOffset, srcHost, ByteCount, hStream)

511

512

513cdef CUresult cuMemcpyAtoHAsync(void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

514 return _driver._cuMemcpyAtoHAsync_v2(dstHost, srcArray, srcOffset, ByteCount, hStream)

515

516

517cdef CUresult cuMemcpy2DAsync(const CUDA_MEMCPY2D* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

518 return _driver._cuMemcpy2DAsync_v2(pCopy, hStream)

519

520

521cdef CUresult cuMemcpy3DAsync(const CUDA_MEMCPY3D* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

522 return _driver._cuMemcpy3DAsync_v2(pCopy, hStream)

523

524

525cdef CUresult cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

526 return _driver._cuMemcpy3DPeerAsync(pCopy, hStream)

527

528

529cdef CUresult cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

530 return _driver._cuMemsetD8_v2(dstDevice, uc, N)

531

532

533cdef CUresult cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

534 return _driver._cuMemsetD16_v2(dstDevice, us, N)

535

536

537cdef CUresult cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

538 return _driver._cuMemsetD32_v2(dstDevice, ui, N)

539

540

541cdef CUresult cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

542 return _driver._cuMemsetD2D8_v2(dstDevice, dstPitch, uc, Width, Height)

543

544

545cdef CUresult cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

546 return _driver._cuMemsetD2D16_v2(dstDevice, dstPitch, us, Width, Height)

547

548

549cdef CUresult cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

550 return _driver._cuMemsetD2D32_v2(dstDevice, dstPitch, ui, Width, Height)

551

552

553cdef CUresult cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

554 return _driver._cuMemsetD8Async(dstDevice, uc, N, hStream) 27 ctx2K N x 9 y z vpypApBpCpJpKpPpSpUpVpWp3p4p9p$p'p(p)p:p;p

555

556

557cdef CUresult cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

558 return _driver._cuMemsetD16Async(dstDevice, us, N, hStream) 18 ctx2wpDpEpFpLpMpQpXpYpZp5p6p!p*p+p,p=p?p

559

560

561cdef CUresult cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

562 return _driver._cuMemsetD32Async(dstDevice, ui, N, hStream) 21 ctx2xpzpGpHpIpNpOpRpTp0p1p2p7p8p#p%p-p.p/p@p[p

563

564

565cdef CUresult cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

566 return _driver._cuMemsetD2D8Async(dstDevice, dstPitch, uc, Width, Height, hStream)

567

568

569cdef CUresult cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

570 return _driver._cuMemsetD2D16Async(dstDevice, dstPitch, us, Width, Height, hStream)

571

572

573cdef CUresult cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

574 return _driver._cuMemsetD2D32Async(dstDevice, dstPitch, ui, Width, Height, hStream)

575

576

577cdef CUresult cuArrayCreate(CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

578 return _driver._cuArrayCreate_v2(pHandle, pAllocateArray) 1 ctx2#Y

579

580

581cdef CUresult cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

582 return _driver._cuArrayGetDescriptor_v2(pArrayDescriptor, hArray)

583

584

585cdef CUresult cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

586 return _driver._cuArrayGetSparseProperties(sparseProperties, array)

587

588

589cdef CUresult cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUmipmappedArray mipmap) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

590 return _driver._cuMipmappedArrayGetSparseProperties(sparseProperties, mipmap)

591

592

593cdef CUresult cuArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUarray array, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

594 return _driver._cuArrayGetMemoryRequirements(memoryRequirements, array, device)

595

596

597cdef CUresult cuMipmappedArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUmipmappedArray mipmap, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

598 return _driver._cuMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)

599

600

601cdef CUresult cuArrayGetPlane(CUarray* pPlaneArray, CUarray hArray, unsigned int planeIdx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

602 return _driver._cuArrayGetPlane(pPlaneArray, hArray, planeIdx)

603

604

605cdef CUresult cuArrayDestroy(CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

606 return _driver._cuArrayDestroy(hArray) 1 ctx2#Y

607

608

609cdef CUresult cuArray3DCreate(CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

610 return _driver._cuArray3DCreate_v2(pHandle, pAllocateArray)

611

612

613cdef CUresult cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

614 return _driver._cuArray3DGetDescriptor_v2(pArrayDescriptor, hArray)

615

616

617cdef CUresult cuMipmappedArrayCreate(CUmipmappedArray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

618 return _driver._cuMipmappedArrayCreate(pHandle, pMipmappedArrayDesc, numMipmapLevels)

619

620

621cdef CUresult cuMipmappedArrayGetLevel(CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

622 return _driver._cuMipmappedArrayGetLevel(pLevelArray, hMipmappedArray, level)

623

624

625cdef CUresult cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

626 return _driver._cuMipmappedArrayDestroy(hMipmappedArray)

627

628

629cdef CUresult cuMemGetHandleForAddressRange(void* handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

630 return _driver._cuMemGetHandleForAddressRange(handle, dptr, size, handleType, flags)

631

632

633cdef CUresult cuMemBatchDecompressAsync(CUmemDecompressParams* paramsArray, size_t count, unsigned int flags, size_t* errorIndex, CUstream stream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

634 return _driver._cuMemBatchDecompressAsync(paramsArray, count, flags, errorIndex, stream)

635

636

637cdef CUresult cuMemAddressReserve(CUdeviceptr* ptr, size_t size, size_t alignment, CUdeviceptr addr, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

638 return _driver._cuMemAddressReserve(ptr, size, alignment, addr, flags) 4 ctx2edfd} gd

639

640

641cdef CUresult cuMemAddressFree(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

642 return _driver._cuMemAddressFree(ptr, size) 4 ctx2edfd} gd

643

644

645cdef CUresult cuMemCreate(CUmemGenericAllocationHandle* handle, size_t size, const CUmemAllocationProp* prop, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

646 return _driver._cuMemCreate(handle, size, prop, flags) 4 ctx2edfd} gd

647

648

649cdef CUresult cuMemRelease(CUmemGenericAllocationHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

650 return _driver._cuMemRelease(handle) 4 ctx2edfd} gd

651

652

653cdef CUresult cuMemMap(CUdeviceptr ptr, size_t size, size_t offset, CUmemGenericAllocationHandle handle, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

654 return _driver._cuMemMap(ptr, size, offset, handle, flags) 4 ctx2edfd} gd

655

656

657cdef CUresult cuMemMapArrayAsync(CUarrayMapInfo* mapInfoList, unsigned int count, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

658 return _driver._cuMemMapArrayAsync(mapInfoList, count, hStream)

659

660

661cdef CUresult cuMemUnmap(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

662 return _driver._cuMemUnmap(ptr, size) 4 ctx2edfd} gd

663

664

665cdef CUresult cuMemSetAccess(CUdeviceptr ptr, size_t size, const CUmemAccessDesc* desc, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

666 return _driver._cuMemSetAccess(ptr, size, desc, count) 4 ctx2edfd} gd

667

668

669cdef CUresult cuMemGetAccess(unsigned long long* flags, const CUmemLocation* location, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

670 return _driver._cuMemGetAccess(flags, location, ptr)

671

672

673cdef CUresult cuMemExportToShareableHandle(void* shareableHandle, CUmemGenericAllocationHandle handle, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

674 return _driver._cuMemExportToShareableHandle(shareableHandle, handle, handleType, flags)

675

676

677cdef CUresult cuMemImportFromShareableHandle(CUmemGenericAllocationHandle* handle, void* osHandle, CUmemAllocationHandleType shHandleType) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

678 return _driver._cuMemImportFromShareableHandle(handle, osHandle, shHandleType)

679

680

681cdef CUresult cuMemGetAllocationGranularity(size_t* granularity, const CUmemAllocationProp* prop, CUmemAllocationGranularity_flags option) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

682 return _driver._cuMemGetAllocationGranularity(granularity, prop, option) 4 ctx2edfd} gd

683

684

685cdef CUresult cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp* prop, CUmemGenericAllocationHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

686 return _driver._cuMemGetAllocationPropertiesFromHandle(prop, handle)

687

688

689cdef CUresult cuMemRetainAllocationHandle(CUmemGenericAllocationHandle* handle, void* addr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

690 return _driver._cuMemRetainAllocationHandle(handle, addr) 4 ctx2edfd} gd

691

692

693cdef CUresult cuMemFreeAsync(CUdeviceptr dptr, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

694 return _driver._cuMemFreeAsync(dptr, hStream) 211 ctx2~ K +b,b-bkdldmdx 9 y z C { D w P Q R NbObPb! # $ dg`d4LPEndRETEegfgqprpsptpupoepeqegghg+x,x-x.x/x:x;x=x?x@x[x]xreQbabbb+ RbSbse6hcbdbebfbgbhb^g_gHbV W kglg+i,iTb|b|kib-iud}kvd}bwd~bZcxdydaczdbcAd0cBdJjccCd.i~kUbdcGeM 6E:E?E^u_u`u{ubrcr|u}u~uavbvqFcvrFdvevsFfvgvhvMF2Ftv'vyH|v}v~vawfrgrbwcwdwewfwZHgw0Hhwiw1Hjwkwlw.HaIxw+w}c?b7J=JgKyKQK8K?KhL#f$forpr%f'f(f)f*fqr+f,f-frr.fsr/ftr:f;fur=fvr?fwr@fxr[fyrzr]f^f_f`f{fAr|fBr}fip

695

696

697cdef CUresult cuMemAllocAsync(CUdeviceptr* dptr, size_t bytesize, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

698 return _driver._cuMemAllocAsync(dptr, bytesize, hStream) 18 ctx2kdldmdx y z C D w P Q R NbObPb! # $

699

700

701cdef CUresult cuMemPoolTrimTo(CUmemoryPool pool, size_t minBytesToKeep) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

702 return _driver._cuMemPoolTrimTo(pool, minBytesToKeep)

703

704

705cdef CUresult cuMemPoolSetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

706 return _driver._cuMemPoolSetAttribute(pool, attr, value) 2 ctx2^x3c

707

708

709cdef CUresult cuMemPoolGetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

710 return _driver._cuMemPoolGetAttribute(pool, attr, value) 160 ctx2K N +b,b-bx 9 y z C { D w ^x^g_gHbV W kglg+i,i$zFC-i!hvevd}b#hwe$hxe%hye'hzewd~b(hmgngZcogpgqgrgxdsg)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBdCdM KjPjQjOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdXj{hciXg}jbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dfkkkFi;gRkWk1k6k#k)k.k?k#f$f%f'f(f)f*f+f,f-f.f/f:f;f=f?f@f[f]f^f_f`f{f|f}fip

711

712

713cdef CUresult cuMemPoolSetAccess(CUmemoryPool pool, const CUmemAccessDesc* map, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

714 return _driver._cuMemPoolSetAccess(pool, map, count) 124 ctx2~ lzmznzoeozpzqzperzqeszgghgtzuzvzwzxzyzzzAzBzCzDzEzFzGzHzIzJzKzLzMzNzOzPzQzRzSzreQbabbb+ RbSbse6hcbdbebfbgbhbTbwt|b7h8h9hibud!hvevd}b#hwe$hxe%hye'hzewd~b(hmgngZcogpgqgrgxdsg)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBdJjccUbdcGewm:h;hM injnknln}c?b

715

716

717cdef CUresult cuMemPoolGetAccess(CUmemAccess_flags* flags, CUmemoryPool memPool, CUmemLocation* location) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

718 return _driver._cuMemPoolGetAccess(flags, memPool, location) 1 ctx2FC

719

720

721cdef CUresult cuMemPoolCreate(CUmemoryPool* pool, const CUmemPoolProps* poolProps) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

722 return _driver._cuMemPoolCreate(pool, poolProps) 134 ctx2yLnxapzLoeoxALpxpeBLqezjCL.q8q/qDLqxELFLGLHLILJLKLLLMLNLOLPLrxsxtxuxvxwxxxgpyxzxAxBxQLCxrm:qRLDxSLEx9q;q+ ~fTLFxULGxVLAjcbdbebfbgbhb^xTbwt|b7h8h9hibud!hvevd}b#hwe$hxe%hye'hzewd~b(hmgngZcogpgqgrgxdsg)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBdJjUbdcGewm:h;hinjnknln}c?b

723

724

725cdef CUresult cuMemPoolDestroy(CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

726 return _driver._cuMemPoolDestroy(pool) 125 ctx2~ lzmznzoeozpzqzperzqeszgghgtzuzvzwzxzyzzzAzBzCzDzEzFzGzHzIzJzKzLzMzNzOzPzQzRzSzreQbabbb+ RbSbse6hcbdbebfbgbhb^xTbwt|b7h8h9hibud!hvevd}b#hwe$hxe%hye'hzewd~b(hmgngZcogpgqgrgxdsg)hAeydac*hBe+hCe,hDe-hEezdbc.hFetgug/hAd0cBdJjccUbdcGewm:h;hM injnknln}c?b

727

728

729cdef CUresult cuMemAllocFromPoolAsync(CUdeviceptr* dptr, size_t bytesize, CUmemoryPool pool, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

730 return _driver._cuMemAllocFromPoolAsync(dptr, bytesize, pool, hStream) 212 ctx2K N +b,b-bx 9 y z C { D w dg`d4LwjndxjyjegfgqprpsptpupapoekqIupeqe% ] gghg+x,x-x.x/x:x;x=x?x@x[x]xlqreJuKumqLuigQbabbb+ ~fRbSbse6hnq7qcbdbebfbgbhb^g_gHbV W kglg+i,iTb|b|kib-iud}kvd}bwd~bZcxdydaczdbcAd0cBdJjCd.i~kUbdcGeM KjPjQjOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdXj{hciXg}jbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dfkkkFi;g}c?bRkWk1k6k#k)k.k?k#f$forpr%f'f(f)f*fqr+f,f-frr.fsr/ftr:f;fur=fvr?fwr@fxr[fyrzr]f^f_f`f{fAr|fBr}fip

731

732

733cdef CUresult cuMemPoolExportToShareableHandle(void* handle_out, CUmemoryPool pool, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

734 return _driver._cuMemPoolExportToShareableHandle(handle_out, pool, handleType, flags) 91 ctx2yLnxapzLoeoxALpxpeBLqezjCL.q8q/qDLqxELFLGLHLILJLKLLLMLNLOLPLrxsxtxuxvxwxxxgpyxzxAxBxQLCxrm:qRLDxSLEx9q;q+ ~fTLFxULGxVLAjcbdbebfbgbhbve}bwexeyeze~bmgAeacBeCeDeEebcFedc:h;hinjnknln}c?b

735

736

737cdef CUresult cuMemPoolImportFromShareableHandle(CUmemoryPool* pool_out, void* handle, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

738 return _driver._cuMemPoolImportFromShareableHandle(pool_out, handle, handleType, flags)

739

740

741cdef CUresult cuMemPoolExportPointer(CUmemPoolPtrExportData* shareData_out, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

742 return _driver._cuMemPoolExportPointer(shareData_out, ptr) 49 ctx2apoekqIupeqe% ] gghg+x,x-x.x/x:x;x=x?x@x[x]xlqreJuKumqLuigQbabbb+ ~fRbSbse6hnq7qcbdbebfbgbhbdc}c?b

743

744

745cdef CUresult cuMemPoolImportPointer(CUdeviceptr* ptr_out, CUmemoryPool pool, CUmemPoolPtrExportData* shareData) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

746 return _driver._cuMemPoolImportPointer(ptr_out, pool, shareData)

747

748

749cdef CUresult cuMulticastCreate(CUmemGenericAllocationHandle* mcHandle, const CUmulticastObjectProp* prop) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

750 return _driver._cuMulticastCreate(mcHandle, prop)

751

752

753cdef CUresult cuMulticastAddDevice(CUmemGenericAllocationHandle mcHandle, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

754 return _driver._cuMulticastAddDevice(mcHandle, dev)

755

756

757cdef CUresult cuMulticastBindMem(CUmemGenericAllocationHandle mcHandle, size_t mcOffset, CUmemGenericAllocationHandle memHandle, size_t memOffset, size_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

758 return _driver._cuMulticastBindMem(mcHandle, mcOffset, memHandle, memOffset, size, flags)

759

760

761cdef CUresult cuMulticastBindAddr(CUmemGenericAllocationHandle mcHandle, size_t mcOffset, CUdeviceptr memptr, size_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

762 return _driver._cuMulticastBindAddr(mcHandle, mcOffset, memptr, size, flags)

763

764

765cdef CUresult cuMulticastUnbind(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, size_t size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

766 return _driver._cuMulticastUnbind(mcHandle, dev, mcOffset, size)

767

768

769cdef CUresult cuMulticastGetGranularity(size_t* granularity, const CUmulticastObjectProp* prop, CUmulticastGranularity_flags option) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

770 return _driver._cuMulticastGetGranularity(granularity, prop, option)

771

772

773cdef CUresult cuPointerGetAttribute(void* data, CUpointer_attribute attribute, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

774 return _driver._cuPointerGetAttribute(data, attribute, ptr) 70 ctx26 7 8 * }dbeeehekene-rIeKeNeXbKdSeMdWeQdTd%e7cob/e3 1b2bqc#c$c%c'cYdZd_e+c|eaf5b8dffhflf$d(dCf:cvbLf4 8b9bFc@c[c]c^c-dRfTf|cWfYf0f2f4f6f8f!f

775

776

777cdef CUresult cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUmemLocation location, unsigned int flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

778 return _driver._cuMemPrefetchAsync_v2(devPtr, count, location, flags, hStream) 5 ctx2tlulndvlwl

779

780

781cdef CUresult cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUmemLocation location) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

782 return _driver._cuMemAdvise_v2(devPtr, count, advice, location) 8 ctx2ssnm}p$Y,r5L6Lhp

783

784

785cdef CUresult cuMemRangeGetAttribute(void* data, size_t dataSize, CUmem_range_attribute attribute, CUdeviceptr devPtr, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

786 return _driver._cuMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) 13 ctx2`dssnm}pndvlwl,r5L6Legfghp

787

788

789cdef CUresult cuMemRangeGetAttributes(void** data, size_t* dataSizes, CUmem_range_attribute* attributes, size_t numAttributes, CUdeviceptr devPtr, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

790 return _driver._cuMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) 1 ctx2hp

791

792

793cdef CUresult cuPointerSetAttribute(const void* value, CUpointer_attribute attribute, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

794 return _driver._cuPointerSetAttribute(value, attribute, ptr) 1 ctx2-r

795

796

797cdef CUresult cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attribute* attributes, void** data, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

798 return _driver._cuPointerGetAttributes(numAttributes, attributes, data, ptr) 116 ctx2S 1 c d e f g h i j k l m n o p q r s t u v G H I J O L A F B b =bE Y Z dg`dssnm}p$YtlulndvlwlDrEr,r5L6Legfg/i-rJ2HbV W ehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhjrkrkglgK2JxKxLxMxoqpq{k|bCd.iM L2M2N2O2P2Q2R2S2T2U2

799

800

801cdef CUresult cuStreamCreate(CUstream* phStream, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

802 return _driver._cuStreamCreate(phStream, Flags) 13 ctx2`i7LGh| %Y@d[d%i'i(ibg)i*i

803

804

805cdef CUresult cuStreamCreateWithPriority(CUstream* phStream, unsigned int flags, int priority) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

806 return _driver._cuStreamCreateWithPriority(phStream, flags, priority) 386 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQccd/b:bLbMbK N X ^ _ ;bO L A F B b +b,b-bkdldmdx 9 y z C { D w P Q R NbObPb! # $ E Y Z Gb)b*bddScU dg`dtlulndvlwlDrEregfgqprpsptpup/i% ] bp]g!i#icpdpepfpxl1L2LigQbabbb+ ~fRbSbcbdbebfbgbhbRxSxTxUxVxWxXxTc0 Ucflglhliljlkl` llmlnlolpl]iEhRc`gjp{g|gkp}g~gahjgbhchdhalIb:iue]d^i_d{bGrHrvpIrwpJrKrxpypLrMrNrzpOrApBpCpDpEpFpGpHpIpPrJpKpLpMpQrNpOpRrSrTrUrPpVrQpWrXrRpSpYrZr0rTp1rUpVpWpXpYpZp0p1p2p2r3p4p5p6p3r7p8p4r5r6r7r9p8r!p9r!r#p$p#r$r%r%p'r'p(p)p*p+p,p-p.p/p(r:p;p=p?p)r@p[p*r+rTbiblpUbqlrlM ;iHtItJtyqpiXgpb{jPtYgCqZg0g1gDqdlqirisi*cQt+c`e|jEqtiuiRtUtVi;gwbQkYt=gPq?g@g[gQqWiXiYiZi{cZt|cUfGoRq0i1i.d/d4t5t6t7t8t9t$t(tYxZx0x1x2x3xCr4x5x6x7x8x9x!x#x$xsl%xnrFr'xFh(x

807

808

809cdef CUresult cuStreamGetPriority(CUstream hStream, int* priority) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

810 return _driver._cuStreamGetPriority(hStream, priority)

811

812

813cdef CUresult cuStreamGetDevice(CUstream hStream, CUdevice* device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

814 return _driver._cuStreamGetDevice(hStream, device)

815

816

817cdef CUresult cuStreamGetFlags(CUstream hStream, unsigned int* flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

818 return _driver._cuStreamGetFlags(hStream, flags)

819

820

821cdef CUresult cuStreamGetId(CUstream hStream, unsigned long long* streamId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

822 return _driver._cuStreamGetId(hStream, streamId)

823

824

825cdef CUresult cuStreamGetCtx(CUstream hStream, CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

826 return _driver._cuStreamGetCtx(hStream, pctx)

827

828

829cdef CUresult cuStreamGetCtx_v2(CUstream hStream, CUcontext* pCtx, CUgreenCtx* pGreenCtx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

830 return _driver._cuStreamGetCtx_v2(hStream, pCtx, pGreenCtx)

831

832

833cdef CUresult cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

834 return _driver._cuStreamWaitEvent(hStream, hEvent, Flags) 24 ctx2T 5 c d e f g h i j k l m n o p q r s t u v U Fh

835

836

837cdef CUresult cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void* userData, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

838 return _driver._cuStreamAddCallback(hStream, callback, userData, flags)

839

840

841cdef CUresult cuStreamBeginCapture(CUstream hStream, CUstreamCaptureMode mode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

842 return _driver._cuStreamBeginCapture_v2(hStream, mode) 63 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J +b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Gb)b*bddScU

843

844

845cdef CUresult cuStreamBeginCaptureToGraph(CUstream hStream, CUgraph hGraph, const CUgraphNode* dependencies, const CUgraphEdgeData* dependencyData, size_t numDependencies, CUstreamCaptureMode mode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

846 return _driver._cuStreamBeginCaptureToGraph(hStream, hGraph, dependencies, dependencyData, numDependencies, mode) 26 ctx1cdefghijklmnopqrstuvGHIJEU

847

848

849cdef CUresult cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode* mode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

850 return _driver._cuThreadExchangeStreamCaptureMode(mode)

851

852

853cdef CUresult cuStreamEndCapture(CUstream hStream, CUgraph* phGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

854 return _driver._cuStreamEndCapture(hStream, phGraph) 63 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J +b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Gb)b*bddScU

855

856

857cdef CUresult cuStreamIsCapturing(CUstream hStream, CUstreamCaptureStatus* captureStatus) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

858 return _driver._cuStreamIsCapturing(hStream, captureStatus) 224 ctx2K N +b,b-bkdldmdx 9 y z C { D w P Q R NbObPb! # $ dg`d4LwjndxjyjegfgqprpsptpupapoekqIupeqe% ] gghg+x,x-x.x/x:x;x=x?x@x[x]xlqreJuKumqLuigQbabbb+ ~fRbSbse6hnq7qcbdbebfbgbhb^g_gHbV W kglg+i,iTb|b|kib-iud}kvd}bwd~bZcxdydaczdbcAd0cBdJjCd.i~kUbdcGeM KjPjQjOe' PeEd1c2c3c[hFdGdHdQeWbWjXb4cAg]hIdJdXj{hciXg}jbf( cf1d^d,c2dxi3d4d5ddf4bek5b-cyizi6d7dfkkkFi;g}c?bRkWk1k6k#k)k.k?k#f$forpr%f'f(f)f*fqr+f,f-frr.fsr/ftr:f;fur=fvr?fwr@fxr[fyrzr]f^f_f`f{fAr|fBr}fip

859

860

861cdef CUresult cuStreamGetCaptureInfo(CUstream hStream, CUstreamCaptureStatus* captureStatus_out, cuuint64_t* id_out, CUgraph* graph_out, const CUgraphNode** dependencies_out, const CUgraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

862 return _driver._cuStreamGetCaptureInfo_v3(hStream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) 63 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J +b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Gb)b*bddScU

863

864

865cdef CUresult cuStreamUpdateCaptureDependencies(CUstream hStream, CUgraphNode* dependencies, const CUgraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

866 return _driver._cuStreamUpdateCaptureDependencies_v2(hStream, dependencies, dependencyData, numDependencies, flags) 27 ctx1ScdefghijklmnopqrstuvGHIJEU

867

868

869cdef CUresult cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

870 return _driver._cuStreamAttachMemAsync(hStream, dptr, length, flags)

871

872

873cdef CUresult cuStreamQuery(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

874 return _driver._cuStreamQuery(hStream)

875

876

877cdef CUresult cuStreamSynchronize(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

878 return _driver._cuStreamSynchronize(hStream) 157 ctx2JbKbS T 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQccd/b:bLbMbK N X ^ _ ;bO L A F B b =bx 9 y z C { D w P Q R NbObPb! # $ E Y Z dg`dtlulndvlwlegfg| Tc0 Uc` HbV W _iIb@d[d%i'i(ibg)i*i]d^iehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhV2ccqlrlM FrFh

879

880

881cdef CUresult cuStreamDestroy(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

882 return _driver._cuStreamDestroy_v2(hStream) 396 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQccd/b:b~ LbMbK N X ^ _ ;bO L A F B b +b,b-bkdldmdx 9 y z C { D w P Q R NbObPb! # $ E Y Z Gb)b*bddScU dg`dtlulndvlwlDrEregfgqprpsptpup/i]g!i#ixl1L2LreQbabbb+ RbSbsecbdbebfbgbhbRxSxTxUxVxWx`i7LGh| XxTc0 Ucflglhliljlkl` llmlnlolpl]iEhRc`g{g|gkp}g~gahbhchdh)xHbV W 3L_iIb:iue%Y@d[d%i'i(ibg)i*i]d^i_d{bGrHrvpIrwpJrKrxpypLrMrNrzpOrApBpCpDpEpFpGpHpIpPrJpKpLpMpQrNpOpRrSrTrUrPpVrQpWrXrRpSpYrZr0rTp1rUpVpWpXpYpZp0p1p2p2r3p4p5p6p3r7p8p4r5r6r7r9p8r!p9r!r#p$p#r$r%r%p'r'p(p)p*p+p,p-p.p/p(r:p;p=p?p)r@p[p*r+rTbibccUbqlrlM ;i-E;EdF)F%v'v(v)vsH*v+vdrer,v-v.v/v:vtH;vuH=v?vvH@v[v]vMHoI*w+w,w-w1J.w/whrir:w;w=w?w@w2J[w3J]w^w4J_w`w{w.d/d.JcKuKMK4K/KdLvLYxZx0x1x2x3xCr4x5x6x7x8x9x!x#x$xsl%xnrFr'xFh(x

883

884

885cdef CUresult cuStreamCopyAttributes(CUstream dst, CUstream src) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

886 return _driver._cuStreamCopyAttributes(dst, src)

887

888

889cdef CUresult cuStreamGetAttribute(CUstream hStream, CUstreamAttrID attr, CUstreamAttrValue* value_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

890 return _driver._cuStreamGetAttribute(hStream, attr, value_out)

891

892

893cdef CUresult cuStreamSetAttribute(CUstream hStream, CUstreamAttrID attr, const CUstreamAttrValue* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

894 return _driver._cuStreamSetAttribute(hStream, attr, value)

895

896

897cdef CUresult cuEventCreate(CUevent* phEvent, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

898 return _driver._cuEventCreate(phEvent, Flags) 255 ctx2T 5 c d e f g h i j k l m n o p q r s t u v .b{d|d~daecedefegeiejeleme~ =d@iLbMb?d[iX U % ] bp]g!i#icpdpepfpxlYLTc0 UcZLsm0Lflglhliljlkl` llmlnlolpl]iEhRc_i'Y;i)zMjNj-zSjTjLeMe1c2cjbkbCgDgZj0jKt}h~hNdOdmrci0bNn@zdi!j#jeiNt$j%j'j(jPd[zQdIgOnOt)j*jfigiZe0e1e2ehi3e4e5e6eRdSd,j-jUdVd8c9c=j?j1b2b(c)c@e[e^j_jCqZg0g`zakbk}e~e^d,cqbrb8g9ghkikaAmknk9d!dqkFi7bfodAGirkskHiVttkukvkwk#deA$d%gKqWtxkykIiJiofpfqfrfKisftfufvf%d'dAkBk)d*d;c=cGkHk8b9b_c`c/g:gNkOkPq?g@g.d/djATkUkmAYkZkqA3k4kuA8k9kyA%k'kCA+k,kFA:k;kIA[k]kslFh

899

900

901cdef CUresult cuEventRecord(CUevent hEvent, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

902 return _driver._cuEventRecord(hEvent, hStream) 58 ctx2T 5 c d e f g h i j k l m n o p q r s t u v U % ] bp]g!i#icpdpepfpxlTc0 Ucflglhliljlkl` llmlnlolpl]iEhRc_i;i.d/dslFh

903

904

905cdef CUresult cuEventRecordWithFlags(CUevent hEvent, CUstream hStream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

906 return _driver._cuEventRecordWithFlags(hEvent, hStream, flags)

907

908

909cdef CUresult cuEventQuery(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

910 return _driver._cuEventQuery(hEvent) 6 ctx2~ =d?d` ]iEh

911

912

913cdef CUresult cuEventSynchronize(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

914 return _driver._cuEventSynchronize(hEvent) 5 ctx20 ` EhRc_i

915

916

917cdef CUresult cuEventDestroy(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

918 return _driver._cuEventDestroy_v2(hEvent) 245 ctx2T 5 c d e f g h i j k l m n o p q r s t u v #u$u%u'u(u)u*u+u,u-u.u/u:u~ =d@i?d[iU !i#ixlYLTc0 UcZLsm0Lflglhliljlkl` llmlnlolpl]iEhRc_i'Ycc;i!E;u=u^E?u@u[u]ubrcrivjvkvlvmvnv6Fovpvqvrvsvtvuvvv^FwvxvyvzvAvBvCvDv_FEv`FFvGv{FHvIvJvKvLvMvNvOvPvQvRvSvTvUvVvWvXvYvZv0v1v2v3v4v5v6v7v8v9v!v#v$v+vdrerCH^v_v`v{vfrgrmwnwowpwqwrweIswtwuwvwwwxwywzwCIAwBwCwDwEwFwGwHwDIIwEIJwKwFILwMwNwOwPwQwRwSwTwUwVwWwXwYwZw0w1w2w3w4w5w6w7w8w9w!w#w$w%w'w(w)w/whrir.d/d#J|w}w]J~waxkKbxcxCKdxexUKfxgx$Khxix^KjxkxlLlxmxslFh

919

920

921cdef CUresult cuEventElapsedTime(float* pMilliseconds, CUevent hStart, CUevent hEnd) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

922 return _driver._cuEventElapsedTime_v2(pMilliseconds, hStart, hEnd) 4 ctx2Tc0 UcRc

923

924

925cdef CUresult cuImportExternalMemory(CUexternalMemory* extMem_out, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC* memHandleDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

926 return _driver._cuImportExternalMemory(extMem_out, memHandleDesc)

927

928

929cdef CUresult cuExternalMemoryGetMappedBuffer(CUdeviceptr* devPtr, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC* bufferDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

930 return _driver._cuExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)

931

932

933cdef CUresult cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray* mipmap, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* mipmapDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

934 return _driver._cuExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)

935

936

937cdef CUresult cuDestroyExternalMemory(CUexternalMemory extMem) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

938 return _driver._cuDestroyExternalMemory(extMem)

939

940

941cdef CUresult cuImportExternalSemaphore(CUexternalSemaphore* extSem_out, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* semHandleDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

942 return _driver._cuImportExternalSemaphore(extSem_out, semHandleDesc)

943

944

945cdef CUresult cuSignalExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

946 return _driver._cuSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)

947

948

949cdef CUresult cuWaitExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

950 return _driver._cuWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)

951

952

953cdef CUresult cuDestroyExternalSemaphore(CUexternalSemaphore extSem) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

954 return _driver._cuDestroyExternalSemaphore(extSem)

955

956

957cdef CUresult cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

958 return _driver._cuStreamWaitValue32_v2(stream, addr, value, flags)

959

960

961cdef CUresult cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

962 return _driver._cuStreamWaitValue64_v2(stream, addr, value, flags)

963

964

965cdef CUresult cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

966 return _driver._cuStreamWriteValue32_v2(stream, addr, value, flags)

967

968

969cdef CUresult cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

970 return _driver._cuStreamWriteValue64_v2(stream, addr, value, flags)

971

972

973cdef CUresult cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams* paramArray, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

974 return _driver._cuStreamBatchMemOp_v2(stream, count, paramArray, flags)

975

976

977cdef CUresult cuFuncGetAttribute(int* pi, CUfunction_attribute attrib, CUfunction hfunc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

978 return _driver._cuFuncGetAttribute(pi, attrib, hfunc)

979

980

981cdef CUresult cuFuncSetAttribute(CUfunction hfunc, CUfunction_attribute attrib, int value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

982 return _driver._cuFuncSetAttribute(hfunc, attrib, value)

983

984

985cdef CUresult cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

986 return _driver._cuFuncSetCacheConfig(hfunc, config)

987

988

989cdef CUresult cuFuncGetModule(CUmodule* hmod, CUfunction hfunc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

990 return _driver._cuFuncGetModule(hmod, hfunc)

991

992

993cdef CUresult cuFuncGetName(const char** name, CUfunction hfunc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

994 return _driver._cuFuncGetName(name, hfunc) 1 ctx2W2

995

996

997cdef CUresult cuFuncGetParamInfo(CUfunction func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

998 return _driver._cuFuncGetParamInfo(func, paramIndex, paramOffset, paramSize)

999

1000

1001cdef CUresult cuFuncIsLoaded(CUfunctionLoadingState* state, CUfunction function) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1002 return _driver._cuFuncIsLoaded(state, function)

1003

1004

1005cdef CUresult cuFuncLoad(CUfunction function) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1006 return _driver._cuFuncLoad(function)

1007

1008

1009cdef CUresult cuLaunchKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void** kernelParams, void** extra) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1010 return _driver._cuLaunchKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra) 8 ctx2@d[d%i'i(ibg)i*i

1011

1012

1013cdef CUresult cuLaunchKernelEx(const CUlaunchConfig* config, CUfunction f, void** kernelParams, void** extra) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1014 return _driver._cuLaunchKernelEx(config, f, kernelParams, extra) 91 ctx2S T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J x 9 y z C { D w P Q R E Y Gb)b*bddScU % ] 0 ` RcHbV W Ib]d^iehfhghhhihVcjhkhlhmhnhWcohphqhrhXcshthuhvhwhxhyhzhAhBhYcChDhM

1015

1016

1017cdef CUresult cuLaunchCooperativeKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void** kernelParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1018 return _driver._cuLaunchCooperativeKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams)

1019

1020

1021cdef CUresult cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS* launchParamsList, unsigned int numDevices, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1022 return _driver._cuLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags)

1023

1024

1025cdef CUresult cuLaunchHostFunc(CUstream hStream, CUhostFn fn, void* userData) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1026 return _driver._cuLaunchHostFunc(hStream, fn, userData) 2 ctx2JbKb

1027

1028

1029cdef CUresult cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1030 return _driver._cuFuncSetBlockShape(hfunc, x, y, z)

1031

1032

1033cdef CUresult cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1034 return _driver._cuFuncSetSharedSize(hfunc, bytes)

1035

1036

1037cdef CUresult cuParamSetSize(CUfunction hfunc, unsigned int numbytes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1038 return _driver._cuParamSetSize(hfunc, numbytes)

1039

1040

1041cdef CUresult cuParamSeti(CUfunction hfunc, int offset, unsigned int value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1042 return _driver._cuParamSeti(hfunc, offset, value)

1043

1044

1045cdef CUresult cuParamSetf(CUfunction hfunc, int offset, float value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1046 return _driver._cuParamSetf(hfunc, offset, value)

1047

1048

1049cdef CUresult cuParamSetv(CUfunction hfunc, int offset, void* ptr, unsigned int numbytes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1050 return _driver._cuParamSetv(hfunc, offset, ptr, numbytes)

1051

1052

1053cdef CUresult cuLaunch(CUfunction f) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1054 return _driver._cuLaunch(f)

1055

1056

1057cdef CUresult cuLaunchGrid(CUfunction f, int grid_width, int grid_height) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1058 return _driver._cuLaunchGrid(f, grid_width, grid_height)

1059

1060

1061cdef CUresult cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1062 return _driver._cuLaunchGridAsync(f, grid_width, grid_height, hStream)

1063

1064

1065cdef CUresult cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1066 return _driver._cuParamSetTexRef(hfunc, texunit, hTexRef)

1067

1068

1069cdef CUresult cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1070 return _driver._cuFuncSetSharedMemConfig(hfunc, config)

1071

1072

1073cdef CUresult cuGraphCreate(CUgraph* phGraph, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1074 return _driver._cuGraphCreate(phGraph, flags) 1003 ctx2XyYyZy0y1y2y3y4y5yEl}iFl6y~iGlHl7y8y9y!y#y{i$y%y'y(y2 )y*y+y,y-y.y/y:y;y=y?ySX@y[y]y^y_y`y{y|y}y~yazbzczdzezfzgzhzizIlJl@baj{d|dbjKlLlMlNlod}dIhJhKhLhOlPlQlRl[bcj~daedjSlTlUlVlpdbeMhNhOhPhWlXlYlejZljzfj0l1l2lgj3lhj4l5l6l7l]bijcedejj8l9l!l#lqdeeQhRhShTh$l%l'l(l^bkjfegelj)l*l+l,lrdheUhVhWhXh-l.l/l:l_bmjiejenj;l=l?l@lsdkeYhZh0h1h[l]l^l_l`bojlemepj`l{l|l}ltdne2h3h4h5h~lambmqjcmrjdmemfmsjgmtjhmim_xjmujkmvjlmmmAl(Y)Y*Y+YQx,Y`x=r`k+q;dBlcdmpnpopppCbDbEbFb/b:b'b~ =d@iLbMb?d[iK N agX ^ _ (b;b=iO L A F B 8L]pylzlb Cl=bDlZ 9L`i.r!L/r:r{x|xGh| }x#L-YmnecrqLjMjNjOj*znnonpnHeIe=h+zrnsnunfctqRjSjTjUj.zvnwnxnJeKe?h/zznAnVbLeMeVjvgwgxgDdNe@hygzgOe' PeEd1c2c3c[hFdGdHdWbXb4c]hIdJdjbkbYb, - . / ^hlbBgCgDgEg_hBnCn5cKdFgvqlrDnEngcwqYjZj0j1j:zFnGnHnReSe`h;zJnKn2jZbLn|h}h~haiLt3j4j5jLdMdGgMt7j8j9jmbNdOdbiTeUeVe6cWeHgXeYemr0bNndi!j#jeiNt$j%j'jPdQdIgOt)j*jfigiZe0e1e2ehi3e4e5e6enbRdSd7e8e9eTdJg!e#ePnhczq+j,j-j.jQnRnSn$e%eii]zTnUnKgLgMgNgVnWnXnYnZnjiicOgPgUdVdQg/j'e(e)e*e7c+e:j,e-ejc8c9c!cWdkclcobmcncoc0npcAq;j=j?j@j^z1n2n3n.e/eki_z5n6n3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jrclimi@e[eni7nRgSgTg]eZdUg9nVgWg!nsc]j^j_j`j#n$n%n^e_eoi'n(npipb{jYgZg0g1gDqdlqiri*c+c`eEqtiui)n*ntcFq~jakbkck{z+n,n-n{e|evi|z/n:n3b}e~edk2g3g4g0dafwi5g6gbf( cf1d^d,c2dxi3d4d5d4b5b-czi6d7dqbrb6b; = ? @ Aisb7g8g9g!gBi;n=n.c8d#gHq?n@n[nucIqgkhkikjk}z]n^n_nefffCi~z{n|n}nvcJqlkmknkokbA~naobogfhfDicAdoeopktb9d!dEiifjfkf/clf$gmfnfqk7bfoGirkskHiVttkukvk#d$d%gWtxkykIiJiofpfqfrfKisftfufvfub%d'dwfxfyf(d'gzfAfgowcLqzkAkBkCkhoiojoBfCfLifAkolo(g)g*g+gmonooopoqoMixc,g-g)d*d.gDkDfEfFfGf:cHfEkIfJfyc;c=c?c+dzcAcvbBcCcDcroEcMqFkGkHkIkgAsotouoKfLfNihAwoxo4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoGcJkKk/g:gLkNqOiPiQiQfRfRiOqSiTiAoHcMkNkOkPkBoCoDoSfTfUiEoFoViwbQk=g?g@g[gQqWiXiYi{c|cUfRq0i1iHoIoIcSqSkTkUkVkkAJoKoLoVfWf2ilANoOoPoJcVqXkYkZk0knAQoRoSoXfYf3ioAUoVoWoKcXq2k3k4k5krAXoYoZoZf0f4isA1o2o3oLcZq7k8k9k!kvA4o5o6o1f2f5iwA8o9o!oMc1q$k%k'k(kzA#o$o%o3f4f6iAA(o)o*oNc3q*k+k,k-kDA+o,o-o5f6f7iEA/o:o;oOc5q/k:k;k=kGA=o?o@o7f8f8iHA]o^o_oPc6q@k[k]k^kJA`o{o|o9f!f9iKA}o~o

1075

1076

1077cdef CUresult cuGraphAddKernelNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1078 return _driver._cuGraphAddKernelNode_v2(phGraphNode, hGraph, dependencies, numDependencies, nodeParams) 156 ctx22 ybzbAb!bBb$i_k@bod[bpd]bqd^brd_bsd`btd;dCbDbEbFb'bK N agX ^ _ (bO L A F B b Z ecHefcJeVbDd' WbjbkbYb, - . / lb5cgcReZbLdmb6c0bPdnbhc$eic*ejc8c9c!cWdkclcobmcncocpc.e3 : rc]esc^epb*ctc{e3b0d( 4bqbrb6b; = ? @ sb.cucefvcgftb/c7b#dubwcBfxcGfyc;c=c?c+dzcAcvbBcCcDcEcKf4 [ GcQfHcSfwb{cIcVfJcXfKcZfLc1fMc3fNc5fOc7fPc9f

1079

1080

1081cdef CUresult cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1082 return _driver._cuGraphKernelNodeGetParams_v2(hNode, nodeParams) 8 ctx2$LCbDbEbFb'b(bb

1083

1084

1085cdef CUresult cuGraphKernelNodeSetParams(CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1086 return _driver._cuGraphKernelNodeSetParams_v2(hNode, nodeParams)

1087

1088

1089cdef CUresult cuGraphAddMemcpyNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_MEMCPY3D* copyParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1090 return _driver._cuGraphAddMemcpyNode(phGraphNode, hGraph, dependencies, numDependencies, copyParams, ctx) 69 ctx26 7 8 * }dbeeehekeneIeKeNeXbKdSeMdWeQdTd%e7cob/e3 1b2bqc#c$c%c'cYdZd_e+c|eaf5b8dffhflf$d(dCf:cvbLf4 8b9bFc@c[c]c^c-dRfTf|cWfYf0f2f4f6f8f!f

1091

1092

1093cdef CUresult cuGraphMemcpyNodeGetParams(CUgraphNode hNode, CUDA_MEMCPY3D* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1094 return _driver._cuGraphMemcpyNodeGetParams(hNode, nodeParams) 1 ctx1|

1095

1096

1097cdef CUresult cuGraphMemcpyNodeSetParams(CUgraphNode hNode, const CUDA_MEMCPY3D* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1098 return _driver._cuGraphMemcpyNodeSetParams(hNode, nodeParams)

1099

1100

1101cdef CUresult cuGraphAddMemsetNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS* memsetParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1102 return _driver._cuGraphAddMemsetNode(phGraphNode, hGraph, dependencies, numDependencies, memsetParams, ctx) 93 ctx26 7 8 * #b$b%bQcIhJhKhLhMhNhOhPhQhRhShThUhVhWhXhYhZh0h1h2h3h4h5hb =b=h?h@h4cFg`hGgHgIgJgii+emcki: (c)cXd:e;eYd=e?eUgoi`eviwi-c#gCiDi$g%g'gLiHfBcNi[ _c`c,dMfNf-dOfPfRiUiUf2i3i4i5i6i7i8i9i

1103

1104

1105cdef CUresult cuGraphMemsetNodeGetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1106 return _driver._cuGraphMemsetNodeGetParams(hNode, nodeParams) 1 ctx1b

1107

1108

1109cdef CUresult cuGraphMemsetNodeSetParams(CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1110 return _driver._cuGraphMemsetNodeSetParams(hNode, nodeParams)

1111

1112

1113cdef CUresult cuGraphAddHostNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1114 return _driver._cuGraphAddHostNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams) 77 ctx2hdidjdKlLlSlTl8l9l)l*l;l=l`l{l/b:b;bnnvnvgFdYb_hFn3jTe$jgihi7eQnKgLgMgNg'eWd1nqcXdRg#ndl+n2g3d6bBi]n~niftkJiKiwfho(g)g*g+gDf+dsoFc,dOiBoWiJoQoXo4o#o+o=o`o

1115

1116

1117cdef CUresult cuGraphHostNodeGetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1118 return _driver._cuGraphHostNodeGetParams(hNode, nodeParams)

1119

1120

1121cdef CUresult cuGraphHostNodeSetParams(CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1122 return _driver._cuGraphHostNodeSetParams(hNode, nodeParams)

1123

1124

1125cdef CUresult cuGraphAddChildGraphNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUgraph childGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1126 return _driver._cuGraphAddChildGraphNode(phGraphNode, hGraph, dependencies, numDependencies, childGraph) 69 ctx2S 2 @b[b]b^b_b`b'b(becfcVb' jbkbYb, - . / lbgcZbmb0bnbhcicjcpc3 : rcscpbtc3b( qbrb6b; = ? @ sbucvctb7bubwcxcycEc4 [ GcHcwbIcJcKcLcMcNcOcPc

1127

1128

1129cdef CUresult cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, CUgraph* phGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1130 return _driver._cuGraphChildGraphNodeGetGraph(hNode, phGraph) 68 ctx22 @b[b]b^b_b`b'b(becfcVb' jbkbYb, - . / lbgcZbmb0bnbhcicjcpc3 : rcscpbtc3b( qbrb6b; = ? @ sbucvctb7bubwcxcycEc4 [ GcHcwbIcJcKcLcMcNcOcPc

1131

1132

1133cdef CUresult cuGraphAddEmptyNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1134 return _driver._cuGraphAddEmptyNode(phGraphNode, hGraph, dependencies, numDependencies) 170 ctx2}i~i{i6 7 8 * (q)q*qaj}dcjbeejfjgjhjijeekjhemjkeojneqjrjsjtj_xujvj`x`kO L A F B 8L]pylzlClDl`i.r/r:r{x|x}x#LLjIeRjKeNeEdXbBgKdYjSe|hMd9jmbNdOdbiTeUeVe6cWeHgXeYediQdTd+j%ePg7cob;j/e3 1b2bqc#c$c%c'cYdmiZd]j_eYg+c~j|eaf1d5b7g8dgkfflkhfpktb9d!dEiifjfkf/clf$gmfnfGi$d(dzkCf-g:cvbFkLf4 8b9bFc@c[c]c^c-dKkRfMkTf=g|cSkWfXkYf2k0f7k2f$k4f*k6f/k8f@k!f

1135

1136

1137cdef CUresult cuGraphAddEventRecordNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1138 return _driver._cuGraphAddEventRecordNode(phGraphNode, hGraph, dependencies, numDependencies, event) 72 ctx2.b{d~dcefeiele~ =d@iLbMbX MjSjLe1cjbCgZj}hNd!jfigiZe0e1e2eRd,jUd8c=j1b(c@e^jZgak}e^dqb8ghkmk9drkIiJiofpfqfrf%dAk)d;cGk8b_c/gNk?gTkYk3k8k%k+k:k[k

1139

1140

1141cdef CUresult cuGraphEventRecordNodeGetEvent(CUgraphNode hNode, CUevent* event_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1142 return _driver._cuGraphEventRecordNodeGetEvent(hNode, event_out)

1143

1144

1145cdef CUresult cuGraphEventRecordNodeSetEvent(CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1146 return _driver._cuGraphEventRecordNodeSetEvent(hNode, event)

1147

1148

1149cdef CUresult cuGraphAddEventWaitNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1150 return _driver._cuGraphAddEventWaitNode(phGraphNode, hGraph, dependencies, numDependencies, event) 70 ctx2.b|daedegejemeLbMb?d[iNjTjMe2ckbDg0j~hOd#jfihi3e4e5e6eSd-jVd9c?j2b)c[e_j0gbk~e,crb9giknk!dskIiKisftfufvf'dBk*d=cHk9b`c:gOk@gUkZk4k9k'k,k;k]k

1151

1152

1153cdef CUresult cuGraphEventWaitNodeGetEvent(CUgraphNode hNode, CUevent* event_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1154 return _driver._cuGraphEventWaitNodeGetEvent(hNode, event_out)

1155

1156

1157cdef CUresult cuGraphEventWaitNodeSetEvent(CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1158 return _driver._cuGraphEventWaitNodeSetEvent(hNode, event)

1159

1160

1161cdef CUresult cuGraphAddExternalSemaphoresSignalNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1162 return _driver._cuGraphAddExternalSemaphoresSignalNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)

1163

1164

1165cdef CUresult cuGraphExternalSemaphoresSignalNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1166 return _driver._cuGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)

1167

1168

1169cdef CUresult cuGraphExternalSemaphoresSignalNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1170 return _driver._cuGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)

1171

1172

1173cdef CUresult cuGraphAddExternalSemaphoresWaitNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1174 return _driver._cuGraphAddExternalSemaphoresWaitNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)

1175

1176

1177cdef CUresult cuGraphExternalSemaphoresWaitNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1178 return _driver._cuGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)

1179

1180

1181cdef CUresult cuGraphExternalSemaphoresWaitNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1182 return _driver._cuGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)

1183

1184

1185cdef CUresult cuGraphAddBatchMemOpNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1186 return _driver._cuGraphAddBatchMemOpNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)

1187

1188

1189cdef CUresult cuGraphBatchMemOpNodeGetParams(CUgraphNode hNode, CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1190 return _driver._cuGraphBatchMemOpNodeGetParams(hNode, nodeParams_out)

1191

1192

1193cdef CUresult cuGraphBatchMemOpNodeSetParams(CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1194 return _driver._cuGraphBatchMemOpNodeSetParams(hNode, nodeParams)

1195

1196

1197cdef CUresult cuGraphExecBatchMemOpNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1198 return _driver._cuGraphExecBatchMemOpNodeSetParams(hGraphExec, hNode, nodeParams)

1199

1200

1201cdef CUresult cuGraphAddMemAllocNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUDA_MEM_ALLOC_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1202 return _driver._cuGraphAddMemAllocNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams) 415 ctx2PAQA!q;rMuRANuEl}iFl~iGlHl#q~cadbd:d6 7 8 * #b$b%bQc$q%q'q(q)q*qIlJlaj{d|dbjod}dIhJhKhLhQlRlcj~daedjpdbeMhNhOhPhYlejZlfj0l1l2lgj3lhj4l5l6l7lijcedejjqdeeQhRhShTh'l(lkjfegeljrdheUhVhWhXh/l:lmjiejenjsdkeYhZh0h1h^l_lojlemepjtdne2h3h4h5hbmqjcmrjdmemfmsjgmtjhmimjmujkmvjlmmm`k+qcd=d?dGhmnLjOjIe=hunRjUjKe?hVbLeMeVjvgwgxgDdNe@hygzgOeEd3cXb4c^hBgEgKdFgEnYj1jSe`h2j|haiMdGg9jmbNdOdbiTeUeVe6cWeHgXeYemrdieiQdIgnbRdSd7e8e9eTdJg!e#ePn+j.j%eiijiPgQg7c+e!cobmc0n;j@j/eki3 1b2bqc#c$c%c'c: (c)cXd:e;eYd=e?e[jminiZdUg!n]j`j_eoipiYg1g+c`e*n~jck|evi3b}e~edk2g3g4g0dafwi5g6gbf1d2d5b-cAi7g!g8d#g[ngkjkffCi}nlkokhfDipktb9d!dEiifjfkf/clf$gmfnfqkGiHi$d%gub%d'dwfxfyf(d'gzfAfgozkCkCfLiMi-g.g:cHf?cvbBcroFkIkLfNi4 8b9bFc@c[c]c^c[ _c`c,dMfNf-dOfPfyoKkLkRfRiAoMkPkTfUiVi=g[g|cUfIoSkVkWf2iPoXk0kYf3iWo2k5k0f4i3o7k!k2f5i!o$k(k4f6i*o*k-k6f7i;o/k=k8f8i_o@k^k!f9i

1203

1204

1205cdef CUresult cuGraphMemAllocNodeGetParams(CUgraphNode hNode, CUDA_MEM_ALLOC_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1206 return _driver._cuGraphMemAllocNodeGetParams(hNode, params_out) 34 ctx2%L'L(L)L*L+L,L-L.L/L:L;L=L?L@L[L]L^L_L`L{L|L}L~xaybycydyeyfygyhyiyjy

1207

1208

1209cdef CUresult cuGraphAddMemFreeNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1210 return _driver._cuGraphAddMemFreeNode(phGraphNode, hGraph, dependencies, numDependencies, dptr) 81 ctx2!q#q~cadbd:d6 7 8 * #b$b%bQcbjdjjjljnjpj=rGhOjUjVj3cEg1jaibieinbRdSd7e8e9eTdJg!e#e.jQg!c@jni`j1gckdk2d!gjkokEiHiub%d'dwfxfyf(d'gzfAfCk.g?cIkLkPk[gVk0k5k!k(k-k=k^k

1211

1212

1213cdef CUresult cuGraphMemFreeNodeGetParams(CUgraphNode hNode, CUdeviceptr* dptr_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1214 return _driver._cuGraphMemFreeNodeGetParams(hNode, dptr_out)

1215

1216

1217cdef CUresult cuDeviceGraphMemTrim(CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1218 return _driver._cuDeviceGraphMemTrim(device) 3 ctx1!#$

1219

1220

1221cdef CUresult cuDeviceGetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1222 return _driver._cuDeviceGetGraphMemAttribute(device, attr, value) 5 ctx2! # $ X2Gh

1223

1224

1225cdef CUresult cuDeviceSetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1226 return _driver._cuDeviceSetGraphMemAttribute(device, attr, value) 3 ctx1!#$

1227

1228

1229cdef CUresult cuGraphClone(CUgraph* phGraphClone, CUgraph originalGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1230 return _driver._cuGraphClone(phGraphClone, originalGraph) 3 ctx2LbN ^

1231

1232

1233cdef CUresult cuGraphNodeFindInClone(CUgraphNode* phNode, CUgraphNode hOriginalNode, CUgraph hClonedGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1234 return _driver._cuGraphNodeFindInClone(phNode, hOriginalNode, hClonedGraph)

1235

1236

1237cdef CUresult cuGraphNodeGetType(CUgraphNode hNode, CUgraphNodeType* type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1238 return _driver._cuGraphNodeGetType(hNode, type) 63 ctx2$L%L'L(L)L*L+L,L-L.L/L:L;L=L?L@L[L]L^L_L`L{L|L}L~xaybycydyeyfy~LgyhyiyjyY2Z202122232425262728292!2#2$2%2'2(2)2CbDbEbFb'b(b=ib

1239

1240

1241cdef CUresult cuGraphGetNodes(CUgraph hGraph, CUgraphNode* nodes, size_t* numNodes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1242 return _driver._cuGraphGetNodes(hGraph, nodes, numNodes) 71 ctx2Px{i$L%L'L*2(L)L*L+2,2-2+L,L-L.L/L:L.2/2:2;2=2?2@2[2]2;L=L^2?L@L[L]L_2`2{2|2^L_L`L{L|L}L}2~2a3b3c3d3e3f3`xmpnpopppCbDbEbFb'b(b=iO L A F B b =b

1243

1244

1245cdef CUresult cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode* rootNodes, size_t* numRootNodes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1246 return _driver._cuGraphGetRootNodes(hGraph, rootNodes, numRootNodes)

1247

1248

1249cdef CUresult cuGraphGetEdges(CUgraph hGraph, CUgraphNode* from_, CUgraphNode* to, CUgraphEdgeData* edgeData, size_t* numEdges) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1250 return _driver._cuGraphGetEdges_v2(hGraph, from_, to, edgeData, numEdges) 16 ctx2g3h3i3j3k3l3m3{iO L A F B b =b.r

1251

1252

1253cdef CUresult cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode* dependencies, CUgraphEdgeData* edgeData, size_t* numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1254 return _driver._cuGraphNodeGetDependencies_v2(hNode, dependencies, edgeData, numDependencies) 40 ctx2!q#q{i(q)q*q$i~xayn3bycydyeyo3p3q3r3fy~Lgyhyiyjys3t3u3v3w3x3y3z3`kX F ylzlb .r:r

1255

1256

1257cdef CUresult cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode* dependentNodes, CUgraphEdgeData* edgeData, size_t* numDependentNodes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1258 return _driver._cuGraphNodeGetDependentNodes_v2(hNode, dependentNodes, edgeData, numDependentNodes) 28 ctx2{i~xaybycydyeyfy~LgyhyiyjyA3B3C3D3E3F3A B ]pylzlb ClDl:r

1259

1260

1261cdef CUresult cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode* from_, const CUgraphNode* to, const CUgraphEdgeData* edgeData, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1262 return _driver._cuGraphAddDependencies_v2(hGraph, from_, to, edgeData, numDependencies) 11 ctx2{iA F B ]pylzlb Cl=bDl

1263

1264

1265cdef CUresult cuGraphRemoveDependencies(CUgraph hGraph, const CUgraphNode* from_, const CUgraphNode* to, const CUgraphEdgeData* edgeData, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1266 return _driver._cuGraphRemoveDependencies_v2(hGraph, from_, to, edgeData, numDependencies) 5 ctx2B ]pylzlb

1267

1268

1269cdef CUresult cuGraphDestroyNode(CUgraphNode hNode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1270 return _driver._cuGraphDestroyNode(hNode) 6 ctx2_xL A F =b#L

1271

1272

1273cdef CUresult cuGraphInstantiate(CUgraphExec* phGraphExec, CUgraph hGraph, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1274 return _driver._cuGraphInstantiateWithFlags(phGraphExec, hGraph, flags) 7 ctx2LbN ^ `iGh| }x

1275

1276

1277cdef CUresult cuGraphInstantiateWithParams(CUgraphExec* phGraphExec, CUgraph hGraph, CUDA_GRAPH_INSTANTIATE_PARAMS* instantiateParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1278 return _driver._cuGraphInstantiateWithParams(phGraphExec, hGraph, instantiateParams) 104 ctx2JbKbcgS T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQc.Y/Y:Y$q%q'q;dcd/b:bMbK X _ ;bO L A F B b +b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Z Gb)b*bSc

1279

1280

1281cdef CUresult cuGraphExecGetFlags(CUgraphExec hGraphExec, cuuint64_t* flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1282 return _driver._cuGraphExecGetFlags(hGraphExec, flags)

1283

1284

1285cdef CUresult cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1286 return _driver._cuGraphExecKernelNodeSetParams_v2(hGraphExec, hNode, nodeParams)

1287

1288

1289cdef CUresult cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMCPY3D* copyParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1290 return _driver._cuGraphExecMemcpyNodeSetParams(hGraphExec, hNode, copyParams, ctx)

1291

1292

1293cdef CUresult cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS* memsetParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1294 return _driver._cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams, ctx)

1295

1296

1297cdef CUresult cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1298 return _driver._cuGraphExecHostNodeSetParams(hGraphExec, hNode, nodeParams)

1299

1300

1301cdef CUresult cuGraphExecChildGraphNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUgraph childGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1302 return _driver._cuGraphExecChildGraphNodeSetParams(hGraphExec, hNode, childGraph)

1303

1304

1305cdef CUresult cuGraphExecEventRecordNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1306 return _driver._cuGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)

1307

1308

1309cdef CUresult cuGraphExecEventWaitNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1310 return _driver._cuGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)

1311

1312

1313cdef CUresult cuGraphExecExternalSemaphoresSignalNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1314 return _driver._cuGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)

1315

1316

1317cdef CUresult cuGraphExecExternalSemaphoresWaitNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1318 return _driver._cuGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)

1319

1320

1321cdef CUresult cuGraphNodeSetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int isEnabled) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1322 return _driver._cuGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)

1323

1324

1325cdef CUresult cuGraphNodeGetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int* isEnabled) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1326 return _driver._cuGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)

1327

1328

1329cdef CUresult cuGraphUpload(CUgraphExec hGraphExec, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1330 return _driver._cuGraphUpload(hGraphExec, hStream) 38 ctx2T ) hd~cadbd2 .bidjdybzbAbBb6 7 8 #b$b%b/b:b;bx y z C D w P Q R NbObPb! # $

1331

1332

1333cdef CUresult cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1334 return _driver._cuGraphLaunch(hGraphExec, hStream) 89 ctx2JbKbS T 1 ) c d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQccd/b:bLbMbK N X ^ _ ;bO L A F B b x y z C D w P Q R NbObPb! # $ E Y Z Gh|

1335

1336

1337cdef CUresult cuGraphExecDestroy(CUgraphExec hGraphExec) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1338 return _driver._cuGraphExecDestroy(hGraphExec) 107 ctx2JbKbcgS T 5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J hd~cadbd:d2 .bidjdybzbAb!bBb6 7 8 * #b$b%bQc.Y/Y:Y$q%q'q;dcd/b:bMbK X _ ;bO L A F B b +b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Z Gb)b*bSc`i| }x

1339

1340

1341cdef CUresult cuGraphDestroy(CUgraph hGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1342 return _driver._cuGraphDestroy(hGraph) 1122 ctx2JbKbcgS T ?i5 1 ) xbc d e f g h i j k l m n o p q r s t u v G H I J HCICJCKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZC0C1C{i2C3C4C5C2 6C#u7C8C9C!C#C$C%C'C(C)C*C+C,C-C.C/C:C;C=C?C@C[C]C^C_C`C{C|C@b}C$u%u~CaDbDcDdDeDfDgDhDiDjDkDlDmD[bnD'u(uoDpDqDrDsDtDuDvDwDxDyDzDADBDCDDDEDFDGDHDIDJDKDLDMDNDOD]bPDQD)u*uRDSDTDUDVDWDXDYDZD0D1D2D3D4D5D^b6D7D+u,u8D9D!D#D$D%D'D(D)D*D+D,D-D.D/D_b:D;D-u.u=D?D@D[D]D^D_D`D{D|D}D~DaEbEcE`bdEeE/u:ufEgEhEiEjEkElEmEnEoEpEqErEsEtEuEvEwExEyEzEAEBECEDE_xEEFEGEHEIEJEAl(Y)Y*Y+YQx,Y`x=r`k+q;dBlcdmpnpopppCbDbEbFb/b:b'b~ =d@iLbMb?d[iK N agX ^ _ (b;b=iO L A F B 8L]pylzlb Cl=bDl+b,b-bkdldmdx y z C D w P Q R NbObPb! # $ E Y Z Gb)b*bddScU 7q`i.r!L/r:r{x|xGh| -Y5Eec7E8E9E;u=u#E$E%E'E(E)E*E+E,E.E/E=Efc@E[E]E?u@u_E`E{E|E}E~EaFbFcFeFfFVbgF[u]uhFiFjFkFlFmFnFoFpF^u' _u`u{ubrcr|u}u~uavbvcvdvevfvgvhvjbivkbjvYbtF, uF- vF. wF/ xFyFlbzFAFkvlvBFCFDFEFFFGFHFIFJFKFLFgcNFOFPFmvnvQFRFSFTFUFVFWFXFYFZF0F1FZb3F4F5Fovpv7F8F9F!F#F$F%F'F(F*F+F,Fmb-Fqvrv.F/F:F;F=F?F@F[F]Fsv0buvvvwvxvyvzvAvBvCvDvEvFvGvHvIvJvKvLvMvNvOvPvQvRvSvTvUvnb|FVvWv}F~FaGbGcGdGeGfGhcgGhGiGXvYvjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzGAGBGCGicDGEGFGZv0vGGHGIGJGKGLGMGNGOGPGQGjcRG1v2vSGTGUGVGWGXGYGZG0Gpc1G2G3G3v4v4G5G6G7G8G9G!G#G$G%G'G3 (G5v6v)G*G+G,G-G: .G7v8v/G:G;G=G?G@G[Grc]G^G_G9v!v`G{G|G}G~GaHbHcHdHeHfHgHschHiH#v$vjHkHlHmHnHoHpHqHrH%vpb(v)v*vdrer,v-v.v/v:v;v=v?v@v[v]vwHxHtczHAHBH^v_vDHEHFHGHHHIHJHKHLHNHOH3bPH`v{vQHRHSHTHUHVHWHXHYH|v( }v~vawfrgrbwcwdwewfwgwhwiwjwkwlwqbmwrbnw6b2H; 3H= 4H? 5H@ 6H7Hsb8H9Howpw!H#H$H%H'H(H)H*H+H,H-Huc/H:H;Hqwrw=H?H@H[H]H^H_H`H{H|H}H~HvcbIcIdIswtwfIgIhIiIjIkIlImInIpIqIrItbsIuwvwtIuIvIwIxIyIzIAIBIww7bywzwAwBwCwDwEwFwGwHwIwJwKwLwMwNwOwPwQwRwSwTwUwVwWwXwYwubGIZw0wHIIIJIKILIMINIOIwcPIQIRI1w2wSITIUIVIWIXIYIZI0I1I2I3I4I5I6I7I8I9I!I#Ixc$I%I'I3w4w(I)I*I+I,I-I.I/I:I;I=Iyc?I5w6w@I[I]I^I_I`I{I|I}IEc~IaJbJ7w8wcJdJeJfJgJhJiJjJkJlJmJ4 nJ9w!woJpJqJrJsJ[ tJ#w$wuJvJwJxJyJzJAJGcBJCJDJ%w'wEJFJGJHJIJJJKJLJMJNJOJPJHcQJRJ(w)wSJTJUJVJWJXJYJZJ0J*wwb,w-w.whrir:w;w=w?w@w[w]w^w_w`w{w5J6JIc8J9J!J|w}w$J%J'J(J)J*J+J,J-J/J:J;JJc?J@J[J~wax^J_J`J{J|J}J~JaKbKdKeKfKKchKiKjKbxcxlKmKnKoKpKqKrKsKtKvKwKxKLczKAKBKdxexDKEKFKGKHKIKJKKKLKNKOKPKMcRKSKTKfxgxVKWKXKYKZK0K1K2K3K5K6K7KNc9K!K#Khxix%K'K(K)K*K+K,K-K.K:K;K=KOc@K[K]Kjxkx_K`K{K|K}K~KaLbLcLeLfLgLPciLjLkLlxmxmLnLoLpLqLrLsLtLuLwLxL

1343

1344

1345cdef CUresult cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraphExecUpdateResultInfo* resultInfo) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1346 return _driver._cuGraphExecUpdate_v2(hGraphExec, hGraph, resultInfo) 4 ctx2E Y Z Gb

1347

1348

1349cdef CUresult cuGraphKernelNodeCopyAttributes(CUgraphNode dst, CUgraphNode src) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1350 return _driver._cuGraphKernelNodeCopyAttributes(dst, src)

1351

1352

1353cdef CUresult cuGraphKernelNodeGetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr, CUkernelNodeAttrValue* value_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1354 return _driver._cuGraphKernelNodeGetAttribute(hNode, attr, value_out)

1355

1356

1357cdef CUresult cuGraphKernelNodeSetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr, const CUkernelNodeAttrValue* value) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1358 return _driver._cuGraphKernelNodeSetAttribute(hNode, attr, value)

1359

1360

1361cdef CUresult cuGraphDebugDotPrint(CUgraph hGraph, const char* path, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1362 return _driver._cuGraphDebugDotPrint(hGraph, path, flags) 3 ctx2MuNuU

1363

1364

1365cdef CUresult cuUserObjectCreate(CUuserObject* object_out, void* ptr, CUhostFn destroy, unsigned int initialRefcount, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1366 return _driver._cuUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) 355 ctx2JbKbhd2 .bidjdybzbAb!bBb$i_k@b{d|dKlLlod[b~daeSlTlpd]bcede8l9lqd^bfege)l*lrd_bieje;l=lsd`bleme`l{ltd;dCbDbEbFb/b:b'b~ =d@iLbMb?d[iK N agX ^ _ (b;bO L A F B b Z ecMjNjnnHefcSjTjvnJeVbLeMevgDd' 1c2cFdWbjbkbYb, - . / lbCgDg_h5cgcZj0jFnReZb}h~h3jLdmbNdOdTe6c0b!j#j$jPdfigiZe0e1e2ehi3e4e5e6enbRdSd7ehc,j-jQn$eKgLgMgNgicUdVd'e*ejc8c9c!cWdkclcobmcncocpc=j?j1n.e3 1b2bqc: (c)cXdrc@e[eRg]esc^j_j#n^epbZg0gdl*ctcakbk+n{e3b}e~e2g0d( ^d,c3d4bqbrb6b; = ? @ sb8g9gBi.cuchkik]nefvcmknk~ngftb9d!dif/c7brksktk#dIiJiofpfqfrfKisftfufvfub%d'dwfwcAkBkhoBf(g)g*g+gxc)d*dDfGfyc;c=c?c+dzcAcvbBcCcDcEcGkHksoKf4 8b9bFc[ _c`c,dGc/g:gOiQfHcNkOkBoSfwb?g@gWi{cIcTkUkJoVfJcYkZkQoXfKc3k4kXoZfLc8k9k4o1fMc%k'k#o3fNc+k,k+o5fOc:k;k=o7fPc[k]k`o9f

1367

1368

1369cdef CUresult cuUserObjectRetain(CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1370 return _driver._cuUserObjectRetain(object, count)

1371

1372

1373cdef CUresult cuUserObjectRelease(CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1374 return _driver._cuUserObjectRelease(object, count)

1375

1376

1377cdef CUresult cuGraphRetainUserObject(CUgraph graph, CUuserObject object, unsigned int count, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1378 return _driver._cuGraphRetainUserObject(graph, object, count, flags) 355 ctx2JbKbhd2 .bidjdybzbAb!bBb$i_k@b{d|dKlLlod[b~daeSlTlpd]bcede8l9lqd^bfege)l*lrd_bieje;l=lsd`bleme`l{ltd;dCbDbEbFb/b:b'b~ =d@iLbMb?d[iK N agX ^ _ (b;bO L A F B b Z ecMjNjnnHefcSjTjvnJeVbLeMevgDd' 1c2cFdWbjbkbYb, - . / lbCgDg_h5cgcZj0jFnReZb}h~h3jLdmbNdOdTe6c0b!j#j$jPdfigiZe0e1e2ehi3e4e5e6enbRdSd7ehc,j-jQn$eKgLgMgNgicUdVd'e*ejc8c9c!cWdkclcobmcncocpc=j?j1n.e3 1b2bqc: (c)cXdrc@e[eRg]esc^j_j#n^epbZg0gdl*ctcakbk+n{e3b}e~e2g0d( ^d,c3d4bqbrb6b; = ? @ sb8g9gBi.cuchkik]nefvcmknk~ngftb9d!dif/c7brksktk#dIiJiofpfqfrfKisftfufvfub%d'dwfwcAkBkhoBf(g)g*g+gxc)d*dDfGfyc;c=c?c+dzcAcvbBcCcDcEcGkHksoKf4 8b9bFc[ _c`c,dGc/g:gOiQfHcNkOkBoSfwb?g@gWi{cIcTkUkJoVfJcYkZkQoXfKc3k4kXoZfLc8k9k4o1fMc%k'k#o3fNc+k,k+o5fOc:k;k=o7fPc[k]k`o9f

1379

1380

1381cdef CUresult cuGraphReleaseUserObject(CUgraph graph, CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1382 return _driver._cuGraphReleaseUserObject(graph, object, count)

1383

1384

1385cdef CUresult cuGraphAddNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, const CUgraphEdgeData* dependencyData, size_t numDependencies, CUgraphNodeParams* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1386 return _driver._cuGraphAddNode_v2(phGraphNode, hGraph, dependencies, dependencyData, numDependencies, nodeParams) 289 ctx2c d e f g h i j k l m n o p q r s t u v G H I J PxMlNlOlPlUlVlWlXl!l#l$l%l+l,l-l.l?l@l[l]l|l}l~lamAlBlmpnpopppCbDbEbFb=iE U 9L/r| onpnrnsnwnxnznAnwgxgygzgGdHdIdJd, - . / BnCnlrDnGnHnJnKn4j5j7j8jUeVeXeYe%j'j)j*jZe0e1e2e3e4e5e6e8e9e!e#eRnSnTnUnKgLgMgNgVnWnXnYnZn(e)e,e-ekclcncoc2n3n5n6n#c$c%c'c:e;e=e?eSgTgVgWg$n%n'n(nqiritiui)n,n-n/n:n3g4g5g6g4d5d6d7d; = ? @ ;n=n?n@n^n_n{n|naobodoeojfkfmfnfukvkxkykofpfqfrfsftfufvfxfyfzfAfiojokolo(g)g*g+gmonooopoqoEfFfIfJfzcAcCcDctouowoxo@c[c]c^cMfNfOfPfPiQiSiTiCoDoEoFoXiYi0i1iHoKoLoNoOoRoSoUoVoYoZo1o2o5o6o8o9o$o%o(o)o,o-o/o:o?o@o]o^o{o|o}o~o

1387

1388

1389cdef CUresult cuGraphNodeSetParams(CUgraphNode hNode, CUgraphNodeParams* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1390 return _driver._cuGraphNodeSetParams(hNode, nodeParams) 1 ctx1|

1391

1392

1393cdef CUresult cuGraphExecNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUgraphNodeParams* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1394 return _driver._cuGraphExecNodeSetParams(hGraphExec, hNode, nodeParams) 1 ctx1|

1395

1396

1397cdef CUresult cuGraphConditionalHandleCreate(CUgraphConditionalHandle* pHandle_out, CUgraph hGraph, CUcontext ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1398 return _driver._cuGraphConditionalHandleCreate(pHandle_out, hGraph, ctx, defaultLaunchValue, flags) 339 ctx2c d e f g h i j k l m n o p q r s t u v G H I J PxMlNlOlPlUlVlWlXl!l#l$l%l+l,l-l.l?l@l[l]l|l}l~lamAlQxBlmpnpopppCbDbEbFb=iE U 9LrqonpnrnsntqwnxnznAnwgxgygzgPeGdHdIdJd, - . / ^hlbBgCgDgEg_hBnCn5cKdFgvqlrDnwqGnHnJnKnLn4j5j7j8jUeVeXeYeNn%j'j)j*jZe0e1e2e3e4e5e6e8e9e!e#ezqRnSnTnUnKgLgMgNgVnWnXnYnZnOg(e)e,e-ekclcncocAq2n3n5n6n#c$c%c'c:e;e=e?eliSgTgVgWg$n%n'n(n{jqiritiui)nFq,n-n/n:n3g4g5g6gcf4d5d6d7d; = ? @ Aisb7g8g9g!gBi;n=n.c8d#gHq?n@nIq^n_n{n|nJqaobodoeojfkfmfnffoukvkxkykofpfqfrfsftfufvfxfyfzfAfLqiojokolo(g)g*g+gmonooopoqo,gEfFfIfJfzcAcCcDcMqtouowoxo@c[c]c^cMfNfOfPfJkPiQiSiTiCoDoEoFoQkXiYi0i1iHoSqKoLoNoOoVqRoSoUoVoXqYoZo1o2oZq5o6o8o9o1q$o%o(o)o3q,o-o/o:o5q?o@o]o^o6q{o|o}o~o

1399

1400

1401cdef CUresult cuOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1402 return _driver._cuOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) 19 ctx2]dSuTuUuVuWuXuYuZu0u1u2u3u4u5u6u7u8u9u

1403

1404

1405cdef CUresult cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1406 return _driver._cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)

1407

1408

1409cdef CUresult cuOccupancyMaxPotentialBlockSize(int* minGridSize, int* blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1410 return _driver._cuOccupancyMaxPotentialBlockSize(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit) 21 ctx2kClCmCnCoCpCqCrCsCtCuCvCwCxCyCzCACBCCCDCEC

1411

1412

1413cdef CUresult cuOccupancyMaxPotentialBlockSizeWithFlags(int* minGridSize, int* blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1414 return _driver._cuOccupancyMaxPotentialBlockSizeWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)

1415

1416

1417cdef CUresult cuOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, CUfunction func, int numBlocks, int blockSize) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1418 return _driver._cuOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) 6 ctx2eCfCgChCiCjC

1419

1420

1421cdef CUresult cuOccupancyMaxPotentialClusterSize(int* clusterSize, CUfunction func, const CUlaunchConfig* config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1422 return _driver._cuOccupancyMaxPotentialClusterSize(clusterSize, func, config)

1423

1424

1425cdef CUresult cuOccupancyMaxActiveClusters(int* numClusters, CUfunction func, const CUlaunchConfig* config) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1426 return _driver._cuOccupancyMaxActiveClusters(numClusters, func, config)

1427

1428

1429cdef CUresult cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1430 return _driver._cuTexRefSetArray(hTexRef, hArray, Flags)

1431

1432

1433cdef CUresult cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1434 return _driver._cuTexRefSetMipmappedArray(hTexRef, hMipmappedArray, Flags)

1435

1436

1437cdef CUresult cuTexRefSetAddress(size_t* ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t bytes) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1438 return _driver._cuTexRefSetAddress_v2(ByteOffset, hTexRef, dptr, bytes)

1439

1440

1441cdef CUresult cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR* desc, CUdeviceptr dptr, size_t Pitch) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1442 return _driver._cuTexRefSetAddress2D_v3(hTexRef, desc, dptr, Pitch)

1443

1444

1445cdef CUresult cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1446 return _driver._cuTexRefSetFormat(hTexRef, fmt, NumPackedComponents)

1447

1448

1449cdef CUresult cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1450 return _driver._cuTexRefSetAddressMode(hTexRef, dim, am)

1451

1452

1453cdef CUresult cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1454 return _driver._cuTexRefSetFilterMode(hTexRef, fm)

1455

1456

1457cdef CUresult cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1458 return _driver._cuTexRefSetMipmapFilterMode(hTexRef, fm)

1459

1460

1461cdef CUresult cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1462 return _driver._cuTexRefSetMipmapLevelBias(hTexRef, bias)

1463

1464

1465cdef CUresult cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1466 return _driver._cuTexRefSetMipmapLevelClamp(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)

1467

1468

1469cdef CUresult cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1470 return _driver._cuTexRefSetMaxAnisotropy(hTexRef, maxAniso)

1471

1472

1473cdef CUresult cuTexRefSetBorderColor(CUtexref hTexRef, float* pBorderColor) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1474 return _driver._cuTexRefSetBorderColor(hTexRef, pBorderColor)

1475

1476

1477cdef CUresult cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1478 return _driver._cuTexRefSetFlags(hTexRef, Flags)

1479

1480

1481cdef CUresult cuTexRefGetAddress(CUdeviceptr* pdptr, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1482 return _driver._cuTexRefGetAddress_v2(pdptr, hTexRef)

1483

1484

1485cdef CUresult cuTexRefGetArray(CUarray* phArray, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1486 return _driver._cuTexRefGetArray(phArray, hTexRef)

1487

1488

1489cdef CUresult cuTexRefGetMipmappedArray(CUmipmappedArray* phMipmappedArray, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1490 return _driver._cuTexRefGetMipmappedArray(phMipmappedArray, hTexRef)

1491

1492

1493cdef CUresult cuTexRefGetAddressMode(CUaddress_mode* pam, CUtexref hTexRef, int dim) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1494 return _driver._cuTexRefGetAddressMode(pam, hTexRef, dim)

1495

1496

1497cdef CUresult cuTexRefGetFilterMode(CUfilter_mode* pfm, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1498 return _driver._cuTexRefGetFilterMode(pfm, hTexRef)

1499

1500

1501cdef CUresult cuTexRefGetFormat(CUarray_format* pFormat, int* pNumChannels, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1502 return _driver._cuTexRefGetFormat(pFormat, pNumChannels, hTexRef)

1503

1504

1505cdef CUresult cuTexRefGetMipmapFilterMode(CUfilter_mode* pfm, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1506 return _driver._cuTexRefGetMipmapFilterMode(pfm, hTexRef)

1507

1508

1509cdef CUresult cuTexRefGetMipmapLevelBias(float* pbias, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1510 return _driver._cuTexRefGetMipmapLevelBias(pbias, hTexRef)

1511

1512

1513cdef CUresult cuTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* pmaxMipmapLevelClamp, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1514 return _driver._cuTexRefGetMipmapLevelClamp(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef)

1515

1516

1517cdef CUresult cuTexRefGetMaxAnisotropy(int* pmaxAniso, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1518 return _driver._cuTexRefGetMaxAnisotropy(pmaxAniso, hTexRef)

1519

1520

1521cdef CUresult cuTexRefGetBorderColor(float* pBorderColor, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1522 return _driver._cuTexRefGetBorderColor(pBorderColor, hTexRef)

1523

1524

1525cdef CUresult cuTexRefGetFlags(unsigned int* pFlags, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1526 return _driver._cuTexRefGetFlags(pFlags, hTexRef)

1527

1528

1529cdef CUresult cuTexRefCreate(CUtexref* pTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1530 return _driver._cuTexRefCreate(pTexRef)

1531

1532

1533cdef CUresult cuTexRefDestroy(CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1534 return _driver._cuTexRefDestroy(hTexRef)

1535

1536

1537cdef CUresult cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1538 return _driver._cuSurfRefSetArray(hSurfRef, hArray, Flags)

1539

1540

1541cdef CUresult cuSurfRefGetArray(CUarray* phArray, CUsurfref hSurfRef) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1542 return _driver._cuSurfRefGetArray(phArray, hSurfRef)

1543

1544

1545cdef CUresult cuTexObjectCreate(CUtexObject* pTexObject, const CUDA_RESOURCE_DESC* pResDesc, const CUDA_TEXTURE_DESC* pTexDesc, const CUDA_RESOURCE_VIEW_DESC* pResViewDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1546 return _driver._cuTexObjectCreate(pTexObject, pResDesc, pTexDesc, pResViewDesc)

1547

1548

1549cdef CUresult cuTexObjectDestroy(CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1550 return _driver._cuTexObjectDestroy(texObject)

1551

1552

1553cdef CUresult cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1554 return _driver._cuTexObjectGetResourceDesc(pResDesc, texObject)

1555

1556

1557cdef CUresult cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC* pTexDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1558 return _driver._cuTexObjectGetTextureDesc(pTexDesc, texObject)

1559

1560

1561cdef CUresult cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC* pResViewDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1562 return _driver._cuTexObjectGetResourceViewDesc(pResViewDesc, texObject)

1563

1564

1565cdef CUresult cuSurfObjectCreate(CUsurfObject* pSurfObject, const CUDA_RESOURCE_DESC* pResDesc) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1566 return _driver._cuSurfObjectCreate(pSurfObject, pResDesc)

1567

1568

1569cdef CUresult cuSurfObjectDestroy(CUsurfObject surfObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1570 return _driver._cuSurfObjectDestroy(surfObject)

1571

1572

1573cdef CUresult cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUsurfObject surfObject) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1574 return _driver._cuSurfObjectGetResourceDesc(pResDesc, surfObject)

1575

1576

1577cdef CUresult cuTensorMapEncodeTiled(CUtensorMap* tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void* globalAddress, const cuuint64_t* globalDim, const cuuint64_t* globalStrides, const cuuint32_t* boxDim, const cuuint32_t* elementStrides, CUtensorMapInterleave interleave, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1578 return _driver._cuTensorMapEncodeTiled(tensorMap, tensorDataType, tensorRank, globalAddress, globalDim, globalStrides, boxDim, elementStrides, interleave, swizzle, l2Promotion, oobFill)

1579

1580

1581cdef CUresult cuTensorMapEncodeIm2col(CUtensorMap* tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void* globalAddress, const cuuint64_t* globalDim, const cuuint64_t* globalStrides, const int* pixelBoxLowerCorner, const int* pixelBoxUpperCorner, cuuint32_t channelsPerPixel, cuuint32_t pixelsPerColumn, const cuuint32_t* elementStrides, CUtensorMapInterleave interleave, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1582 return _driver._cuTensorMapEncodeIm2col(tensorMap, tensorDataType, tensorRank, globalAddress, globalDim, globalStrides, pixelBoxLowerCorner, pixelBoxUpperCorner, channelsPerPixel, pixelsPerColumn, elementStrides, interleave, swizzle, l2Promotion, oobFill)

1583

1584

1585cdef CUresult cuTensorMapEncodeIm2colWide(CUtensorMap* tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void* globalAddress, const cuuint64_t* globalDim, const cuuint64_t* globalStrides, int pixelBoxLowerCornerWidth, int pixelBoxUpperCornerWidth, cuuint32_t channelsPerPixel, cuuint32_t pixelsPerColumn, const cuuint32_t* elementStrides, CUtensorMapInterleave interleave, CUtensorMapIm2ColWideMode mode, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1586 return _driver._cuTensorMapEncodeIm2colWide(tensorMap, tensorDataType, tensorRank, globalAddress, globalDim, globalStrides, pixelBoxLowerCornerWidth, pixelBoxUpperCornerWidth, channelsPerPixel, pixelsPerColumn, elementStrides, interleave, mode, swizzle, l2Promotion, oobFill)

1587

1588

1589cdef CUresult cuTensorMapReplaceAddress(CUtensorMap* tensorMap, void* globalAddress) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1590 return _driver._cuTensorMapReplaceAddress(tensorMap, globalAddress)

1591

1592

1593cdef CUresult cuDeviceCanAccessPeer(int* canAccessPeer, CUdevice dev, CUdevice peerDev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1594 return _driver._cuDeviceCanAccessPeer(canAccessPeer, dev, peerDev)

1595

1596

1597cdef CUresult cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1598 return _driver._cuCtxEnablePeerAccess(peerContext, Flags)

1599

1600

1601cdef CUresult cuCtxDisablePeerAccess(CUcontext peerContext) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1602 return _driver._cuCtxDisablePeerAccess(peerContext)

1603

1604

1605cdef CUresult cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib, CUdevice srcDevice, CUdevice dstDevice) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1606 return _driver._cuDeviceGetP2PAttribute(value, attrib, srcDevice, dstDevice)

1607

1608

1609cdef CUresult cuGraphicsUnregisterResource(CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1610 return _driver._cuGraphicsUnregisterResource(resource) 24 ctx2]g`g{g|gkp;Y=Y?Y@Y[Y]Y}g~gahjg^Ybhch_Ydh`Y{Y|Y}Y

1611

1612

1613cdef CUresult cuGraphicsSubResourceGetMappedArray(CUarray* pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1614 return _driver._cuGraphicsSubResourceGetMappedArray(pArray, resource, arrayIndex, mipLevel)

1615

1616

1617cdef CUresult cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray* pMipmappedArray, CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1618 return _driver._cuGraphicsResourceGetMappedMipmappedArray(pMipmappedArray, resource)

1619

1620

1621cdef CUresult cuGraphicsResourceGetMappedPointer(CUdeviceptr* pDevPtr, size_t* pSize, CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1622 return _driver._cuGraphicsResourceGetMappedPointer_v2(pDevPtr, pSize, resource) 12 ctx2`gjp{g|g}g~gahjgbhchdhal

1623

1624

1625cdef CUresult cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1626 return _driver._cuGraphicsResourceSetMapFlags_v2(resource, flags)

1627

1628

1629cdef CUresult cuGraphicsMapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1630 return _driver._cuGraphicsMapResources(count, resources, hStream) 12 ctx2`gjp{g|g}g~gahjgbhchdhal

1631

1632

1633cdef CUresult cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1634 return _driver._cuGraphicsUnmapResources(count, resources, hStream) 12 ctx2]g`g{g|g}g~gahjgbhchdhal

1635

1636

1637cdef CUresult cuGetProcAddress(const char* symbol, void** pfn, int cudaVersion, cuuint64_t flags, CUdriverProcAddressQueryResult* symbolStatus) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1638 return _driver._cuGetProcAddress_v2(symbol, pfn, cudaVersion, flags, symbolStatus)

1639

1640

1641cdef CUresult cuCoredumpGetAttribute(CUcoredumpSettings attrib, void* value, size_t* size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1642 return _driver._cuCoredumpGetAttribute(attrib, value, size)

1643

1644

1645cdef CUresult cuCoredumpGetAttributeGlobal(CUcoredumpSettings attrib, void* value, size_t* size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1646 return _driver._cuCoredumpGetAttributeGlobal(attrib, value, size) 1 ctx2~Y

1647

1648

1649cdef CUresult cuCoredumpSetAttribute(CUcoredumpSettings attrib, void* value, size_t* size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1650 return _driver._cuCoredumpSetAttribute(attrib, value, size)

1651

1652

1653cdef CUresult cuCoredumpSetAttributeGlobal(CUcoredumpSettings attrib, void* value, size_t* size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1654 return _driver._cuCoredumpSetAttributeGlobal(attrib, value, size) 1 ctx2~Y

1655

1656

1657cdef CUresult cuGetExportTable(const void** ppExportTable, const CUuuid* pExportTableId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1658 return _driver._cuGetExportTable(ppExportTable, pExportTableId)

1659

1660

1661cdef CUresult cuGreenCtxCreate(CUgreenCtx* phCtx, CUdevResourceDesc desc, CUdevice dev, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1662 return _driver._cuGreenCtxCreate(phCtx, desc, dev, flags) 12 ctx2elBjCjteV W DjEjFjGjHjIj

1663

1664

1665cdef CUresult cuGreenCtxDestroy(CUgreenCtx hCtx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1666 return _driver._cuGreenCtxDestroy(hCtx) 12 ctx2elWEXEYEV W ZE0E1E2E3E4E

1667

1668

1669cdef CUresult cuCtxFromGreenCtx(CUcontext* pContext, CUgreenCtx hCtx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1670 return _driver._cuCtxFromGreenCtx(pContext, hCtx) 12 ctx2elBjCjteV W DjEjFjGjHjIj

1671

1672

1673cdef CUresult cuDeviceGetDevResource(CUdevice device, CUdevResource* resource, CUdevResourceType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1674 return _driver._cuDeviceGetDevResource(device, resource, type) 32 ctx2aZbZTzBjCjtetmumDjEjFjGjHjIjUzVzWzXzYzZz0z1z2z3z4z5z6z7z8z9z!z#z

1675

1676

1677cdef CUresult cuCtxGetDevResource(CUcontext hCtx, CUdevResource* resource, CUdevResourceType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1678 return _driver._cuCtxGetDevResource(hCtx, resource, type)

1679

1680

1681cdef CUresult cuGreenCtxGetDevResource(CUgreenCtx hCtx, CUdevResource* resource, CUdevResourceType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1682 return _driver._cuGreenCtxGetDevResource(hCtx, resource, type) 3 ctx2elG3)x

1683

1684

1685cdef CUresult cuDevSmResourceSplitByCount(CUdevResource* result, unsigned int* nbGroups, const CUdevResource* input, CUdevResource* remainder, unsigned int flags, unsigned int minCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1686 return _driver._cuDevSmResourceSplitByCount(result, nbGroups, input, remainder, flags, minCount) 1 ctx2bZ

1687

1688

1689cdef CUresult cuDevResourceGenerateDesc(CUdevResourceDesc* phDesc, CUdevResource* resources, unsigned int nbResources) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1690 return _driver._cuDevResourceGenerateDesc(phDesc, resources, nbResources) 12 ctx2elBjCjteV W DjEjFjGjHjIj

1691

1692

1693cdef CUresult cuGreenCtxRecordEvent(CUgreenCtx hCtx, CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1694 return _driver._cuGreenCtxRecordEvent(hCtx, hEvent)

1695

1696

1697cdef CUresult cuGreenCtxWaitEvent(CUgreenCtx hCtx, CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1698 return _driver._cuGreenCtxWaitEvent(hCtx, hEvent)

1699

1700

1701cdef CUresult cuStreamGetGreenCtx(CUstream hStream, CUgreenCtx* phCtx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1702 return _driver._cuStreamGetGreenCtx(hStream, phCtx)

1703

1704

1705cdef CUresult cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, unsigned int flags, int priority) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1706 return _driver._cuGreenCtxStreamCreate(phStream, greenCtx, flags, priority) 7 ctx2)xHbV W QY3L_i

1707

1708

1709cdef CUresult cuLogsRegisterCallback(CUlogsCallback callbackFunc, void* userData, CUlogsCallbackHandle* callback_out) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1710 return _driver._cuLogsRegisterCallback(callbackFunc, userData, callback_out)

1711

1712

1713cdef CUresult cuLogsUnregisterCallback(CUlogsCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1714 return _driver._cuLogsUnregisterCallback(callback)

1715

1716

1717cdef CUresult cuLogsCurrent(CUlogIterator* iterator_out, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1718 return _driver._cuLogsCurrent(iterator_out, flags)

1719

1720

1721cdef CUresult cuLogsDumpToFile(CUlogIterator* iterator, const char* pathToFile, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1722 return _driver._cuLogsDumpToFile(iterator, pathToFile, flags)

1723

1724

1725cdef CUresult cuLogsDumpToMemory(CUlogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1726 return _driver._cuLogsDumpToMemory(iterator, buffer, size, flags)

1727

1728

1729cdef CUresult cuCheckpointProcessGetRestoreThreadId(int pid, int* tid) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1730 return _driver._cuCheckpointProcessGetRestoreThreadId(pid, tid)

1731

1732

1733cdef CUresult cuCheckpointProcessGetState(int pid, CUprocessState* state) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1734 return _driver._cuCheckpointProcessGetState(pid, state) 1 ctx2H3

1735

1736

1737cdef CUresult cuCheckpointProcessLock(int pid, CUcheckpointLockArgs* args) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1738 return _driver._cuCheckpointProcessLock(pid, args)

1739

1740

1741cdef CUresult cuCheckpointProcessCheckpoint(int pid, CUcheckpointCheckpointArgs* args) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1742 return _driver._cuCheckpointProcessCheckpoint(pid, args)

1743

1744

1745cdef CUresult cuCheckpointProcessRestore(int pid, CUcheckpointRestoreArgs* args) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1746 return _driver._cuCheckpointProcessRestore(pid, args)

1747

1748

1749cdef CUresult cuCheckpointProcessUnlock(int pid, CUcheckpointUnlockArgs* args) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1750 return _driver._cuCheckpointProcessUnlock(pid, args)

1751

1752

1753cdef CUresult cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGLImageKHR image, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1754 return _driver._cuGraphicsEGLRegisterImage(pCudaResource, image, flags)

1755

1756

1757cdef CUresult cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1758 return _driver._cuEGLStreamConsumerConnect(conn, stream)

1759

1760

1761cdef CUresult cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn, EGLStreamKHR stream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1762 return _driver._cuEGLStreamConsumerConnectWithFlags(conn, stream, flags)

1763

1764

1765cdef CUresult cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1766 return _driver._cuEGLStreamConsumerDisconnect(conn)

1767

1768

1769cdef CUresult cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgraphicsResource* pCudaResource, CUstream* pStream, unsigned int timeout) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1770 return _driver._cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)

1771

1772

1773cdef CUresult cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgraphicsResource pCudaResource, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1774 return _driver._cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)

1775

1776

1777cdef CUresult cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream, EGLint width, EGLint height) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1778 return _driver._cuEGLStreamProducerConnect(conn, stream, width, height)

1779

1780

1781cdef CUresult cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1782 return _driver._cuEGLStreamProducerDisconnect(conn)

1783

1784

1785cdef CUresult cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1786 return _driver._cuEGLStreamProducerPresentFrame(conn, eglframe, pStream)

1787

1788

1789cdef CUresult cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1790 return _driver._cuEGLStreamProducerReturnFrame(conn, eglframe, pStream)

1791

1792

1793cdef CUresult cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraphicsResource resource, unsigned int index, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1794 return _driver._cuGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)

1795

1796

1797cdef CUresult cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1798 return _driver._cuEventCreateFromEGLSync(phEvent, eglSync, flags)

1799

1800

1801cdef CUresult cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1802 return _driver._cuGraphicsGLRegisterBuffer(pCudaResource, buffer, Flags) 24 ctx2`gjp{g|gkp;Y=Y?Y@Y[Y}g~gahjg^Ybhch_Ydhal`Y{Y|Y}Y

1803

1804

1805cdef CUresult cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1806 return _driver._cuGraphicsGLRegisterImage(pCudaResource, image, target, Flags) 1 ctx2]Y

1807

1808

1809cdef CUresult cuGLGetDevices(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1810 return _driver._cuGLGetDevices_v2(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)

1811

1812

1813cdef CUresult cuGLCtxCreate(CUcontext* pCtx, unsigned int Flags, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1814 return _driver._cuGLCtxCreate_v2(pCtx, Flags, device)

1815

1816

1817cdef CUresult cuGLInit() except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1818 return _driver._cuGLInit()

1819

1820

1821cdef CUresult cuGLRegisterBufferObject(GLuint buffer) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1822 return _driver._cuGLRegisterBufferObject(buffer)

1823

1824

1825cdef CUresult cuGLMapBufferObject(CUdeviceptr* dptr, size_t* size, GLuint buffer) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1826 return _driver._cuGLMapBufferObject_v2(dptr, size, buffer)

1827

1828

1829cdef CUresult cuGLUnmapBufferObject(GLuint buffer) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1830 return _driver._cuGLUnmapBufferObject(buffer)

1831

1832

1833cdef CUresult cuGLUnregisterBufferObject(GLuint buffer) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1834 return _driver._cuGLUnregisterBufferObject(buffer)

1835

1836

1837cdef CUresult cuGLSetBufferObjectMapFlags(GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1838 return _driver._cuGLSetBufferObjectMapFlags(buffer, Flags)

1839

1840

1841cdef CUresult cuGLMapBufferObjectAsync(CUdeviceptr* dptr, size_t* size, GLuint buffer, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1842 return _driver._cuGLMapBufferObjectAsync_v2(dptr, size, buffer, hStream)

1843

1844

1845cdef CUresult cuGLUnmapBufferObjectAsync(GLuint buffer, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1846 return _driver._cuGLUnmapBufferObjectAsync(buffer, hStream)

1847

1848

1849cdef CUresult cuProfilerInitialize(const char* configFile, const char* outputFile, CUoutput_mode outputMode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1850 return _driver._cuProfilerInitialize(configFile, outputFile, outputMode)

1851

1852

1853cdef CUresult cuProfilerStart() except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1854 return _driver._cuProfilerStart() 1 ctx2cZ

1855

1856

1857cdef CUresult cuProfilerStop() except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1858 return _driver._cuProfilerStop() 1 ctx2cZ

1859

1860

1861cdef CUresult cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1862 return _driver._cuVDPAUGetDevice(pDevice, vdpDevice, vdpGetProcAddress)

1863

1864

1865cdef CUresult cuVDPAUCtxCreate(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1866 return _driver._cuVDPAUCtxCreate_v2(pCtx, flags, device, vdpDevice, vdpGetProcAddress)

1867

1868

1869cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1870 return _driver._cuGraphicsVDPAURegisterVideoSurface(pCudaResource, vdpSurface, flags)

1871

1872

1873cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1874 return _driver._cuGraphicsVDPAURegisterOutputSurface(pCudaResource, vdpSurface, flags)

1875

1876

1877cdef CUresult cuDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const CUatomicOperation* operations, unsigned int count, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1878 return _driver._cuDeviceGetHostAtomicCapabilities(capabilities, operations, count, dev)

1879

1880

1881cdef CUresult cuCtxGetDevice_v2(CUdevice* device, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1882 return _driver._cuCtxGetDevice_v2(device, ctx)

1883

1884

1885cdef CUresult cuCtxSynchronize_v2(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1886 return _driver._cuCtxSynchronize_v2(ctx)

1887

1888

1889cdef CUresult cuMemcpyBatchAsync(CUdeviceptr* dsts, CUdeviceptr* srcs, size_t* sizes, size_t count, CUmemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1890 return _driver._cuMemcpyBatchAsync_v2(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, hStream)

1891

1892

1893cdef CUresult cuMemcpy3DBatchAsync(size_t numOps, CUDA_MEMCPY3D_BATCH_OP* opList, unsigned long long flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1894 return _driver._cuMemcpy3DBatchAsync_v2(numOps, opList, flags, hStream)

1895

1896

1897cdef CUresult cuMemGetDefaultMemPool(CUmemoryPool* pool_out, CUmemLocation* location, CUmemAllocationType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1898 return _driver._cuMemGetDefaultMemPool(pool_out, location, type)

1899

1900

1901cdef CUresult cuMemGetMemPool(CUmemoryPool* pool, CUmemLocation* location, CUmemAllocationType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1902 return _driver._cuMemGetMemPool(pool, location, type) 49 ctx2_p`pbqomwjndpmxjqmyjOueqfqgqhqiqjq{k|bPu|kQu7h8h9hRuibud}kng{BZc|Bog}Bpg~BqgaCrgbCxdcCsgdCug0c.i~k

1903

1904

1905cdef CUresult cuMemSetMemPool(CUmemLocation* location, CUmemAllocationType type, CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1906 return _driver._cuMemSetMemPool(location, type, pool)

1907

1908

1909cdef CUresult cuMemPrefetchBatchAsync(CUdeviceptr* dptrs, size_t* sizes, size_t count, CUmemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1910 return _driver._cuMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, hStream) 4 ctx2dg`degfg

1911

1912

1913cdef CUresult cuMemDiscardBatchAsync(CUdeviceptr* dptrs, size_t* sizes, size_t count, unsigned long long flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1914 return _driver._cuMemDiscardBatchAsync(dptrs, sizes, count, flags, hStream) 3 ctx2dgtlul

1915

1916

1917cdef CUresult cuMemDiscardAndPrefetchBatchAsync(CUdeviceptr* dptrs, size_t* sizes, size_t count, CUmemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1918 return _driver._cuMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, hStream) 2 ctx2`dnd

1919

1920

1921cdef CUresult cuDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const CUatomicOperation* operations, unsigned int count, CUdevice srcDevice, CUdevice dstDevice) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1922 return _driver._cuDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice)

1923

1924

1925cdef CUresult cuGreenCtxGetId(CUgreenCtx greenCtx, unsigned long long* greenCtxId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1926 return _driver._cuGreenCtxGetId(greenCtx, greenCtxId)

1927

1928

1929cdef CUresult cuMulticastBindMem_v2(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, CUmemGenericAllocationHandle memHandle, size_t memOffset, size_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1930 return _driver._cuMulticastBindMem_v2(mcHandle, dev, mcOffset, memHandle, memOffset, size, flags)

1931

1932

1933cdef CUresult cuMulticastBindAddr_v2(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, CUdeviceptr memptr, size_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1934 return _driver._cuMulticastBindAddr_v2(mcHandle, dev, mcOffset, memptr, size, flags)

1935

1936

1937cdef CUresult cuGraphNodeGetContainingGraph(CUgraphNode hNode, CUgraph* phGraph) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1938 return _driver._cuGraphNodeGetContainingGraph(hNode, phGraph) 1 ctx2/r

1939

1940

1941cdef CUresult cuGraphNodeGetLocalId(CUgraphNode hNode, unsigned int* nodeId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1942 return _driver._cuGraphNodeGetLocalId(hNode, nodeId) 1 ctx2{x

1943

1944

1945cdef CUresult cuGraphNodeGetToolsId(CUgraphNode hNode, unsigned long long* toolsNodeId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1946 return _driver._cuGraphNodeGetToolsId(hNode, toolsNodeId) 1 ctx2|x

1947

1948

1949cdef CUresult cuGraphGetId(CUgraph hGraph, unsigned int* graphId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1950 return _driver._cuGraphGetId(hGraph, graphId) 1 ctx2!L

1951

1952

1953cdef CUresult cuGraphExecGetId(CUgraphExec hGraphExec, unsigned int* graphId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1954 return _driver._cuGraphExecGetId(hGraphExec, graphId) 1 ctx2`i

1955

1956

1957cdef CUresult cuDevSmResourceSplit(CUdevResource* result, unsigned int nbGroups, const CUdevResource* input, CUdevResource* remainder, unsigned int flags, CU_DEV_SM_RESOURCE_GROUP_PARAMS* groupParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1958 return _driver._cuDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) 20 ctx2aZelBjCjteV W DjEjFjGjHjIjI3J3K3L3M3N3O3

1959

1960

1961cdef CUresult cuStreamGetDevResource(CUstream hStream, CUdevResource* resource, CUdevResourceType type) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1962 return _driver._cuStreamGetDevResource(hStream, resource, type) 1 ctx27L

1963

1964

1965cdef CUresult cuKernelGetParamCount(CUkernel kernel, size_t* paramCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1966 return _driver._cuKernelGetParamCount(kernel, paramCount)

1967

1968

1969cdef CUresult cuMemcpyWithAttributesAsync(CUdeviceptr dst, CUdeviceptr src, size_t size, CUmemcpyAttributes* attr, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1970 return _driver._cuMemcpyWithAttributesAsync(dst, src, size, attr, hStream)

1971

1972

1973cdef CUresult cuMemcpy3DWithAttributesAsync(CUDA_MEMCPY3D_BATCH_OP* op, unsigned long long flags, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1974 return _driver._cuMemcpy3DWithAttributesAsync(op, flags, hStream)

1975

1976

1977cdef CUresult cuStreamBeginCaptureToCig(CUstream hStream, CUstreamCigCaptureParams* streamCigCaptureParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1978 return _driver._cuStreamBeginCaptureToCig(hStream, streamCigCaptureParams)

1979

1980

1981cdef CUresult cuStreamEndCaptureToCig(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1982 return _driver._cuStreamEndCaptureToCig(hStream)

1983

1984

1985cdef CUresult cuFuncGetParamCount(CUfunction func, size_t* paramCount) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1986 return _driver._cuFuncGetParamCount(func, paramCount)

1987

1988

1989cdef CUresult cuLaunchHostFunc_v2(CUstream hStream, CUhostFn fn, void* userData, unsigned int syncMode) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1990 return _driver._cuLaunchHostFunc_v2(hStream, fn, userData, syncMode)

1991

1992

1993cdef CUresult cuGraphNodeGetParams(CUgraphNode hNode, CUgraphNodeParams* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1994 return _driver._cuGraphNodeGetParams(hNode, nodeParams) 1 ctx2=i

1995

1996

1997cdef CUresult cuCoredumpRegisterStartCallback(CUcoredumpStatusCallback callback, void* userData, CUcoredumpCallbackHandle* callbackOut) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

1998 return _driver._cuCoredumpRegisterStartCallback(callback, userData, callbackOut)

1999

2000

2001cdef CUresult cuCoredumpRegisterCompleteCallback(CUcoredumpStatusCallback callback, void* userData, CUcoredumpCallbackHandle* callbackOut) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2002 return _driver._cuCoredumpRegisterCompleteCallback(callback, userData, callbackOut)

2003

2004

2005cdef CUresult cuCoredumpDeregisterStartCallback(CUcoredumpCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2006 return _driver._cuCoredumpDeregisterStartCallback(callback)

2007

2008

2009cdef CUresult cuCoredumpDeregisterCompleteCallback(CUcoredumpCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2010 return _driver._cuCoredumpDeregisterCompleteCallback(callback)

2011

2012

2013cdef CUresult cuLogicalEndpointIdReserve(CUlogicalEndpointId* baseLeId, cuuint32_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2014 return _driver._cuLogicalEndpointIdReserve(baseLeId, count)

2015

2016

2017cdef CUresult cuLogicalEndpointIdRelease(CUlogicalEndpointId baseLeId, cuuint32_t count) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2018 return _driver._cuLogicalEndpointIdRelease(baseLeId, count)

2019

2020

2021cdef CUresult cuLogicalEndpointCreate(CUlogicalEndpointId leId, const CUlogicalEndpointProp* prop) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2022 return _driver._cuLogicalEndpointCreate(leId, prop)

2023

2024

2025cdef CUresult cuLogicalEndpointAddDevice(CUlogicalEndpointId leId, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2026 return _driver._cuLogicalEndpointAddDevice(leId, dev)

2027

2028

2029cdef CUresult cuLogicalEndpointDestroy(CUlogicalEndpointId leId) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2030 return _driver._cuLogicalEndpointDestroy(leId)

2031

2032

2033cdef CUresult cuLogicalEndpointBindAddr(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, void* ptr, cuuint64_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2034 return _driver._cuLogicalEndpointBindAddr(leId, dev, offset, ptr, size, flags)

2035

2036

2037cdef CUresult cuLogicalEndpointBindMem(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, CUmemGenericAllocationHandle memHandle, cuuint64_t memOffset, cuuint64_t size, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2038 return _driver._cuLogicalEndpointBindMem(leId, dev, offset, memHandle, memOffset, size, flags)

2039

2040

2041cdef CUresult cuLogicalEndpointUnbind(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, cuuint64_t size) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2042 return _driver._cuLogicalEndpointUnbind(leId, dev, offset, size)

2043

2044

2045cdef CUresult cuLogicalEndpointExport(void* handle, CUlogicalEndpointId leId, CUlogicalEndpointIpcHandleType handleType) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2046 return _driver._cuLogicalEndpointExport(handle, leId, handleType)

2047

2048

2049cdef CUresult cuLogicalEndpointImport(CUlogicalEndpointId leId, const void* handle, CUlogicalEndpointIpcHandleType handleType) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2050 return _driver._cuLogicalEndpointImport(leId, handle, handleType)

2051

2052

2053cdef CUresult cuLogicalEndpointGetLimits(cuuint64_t* bindAlignment, cuuint64_t* maxSize, const CUlogicalEndpointProp* prop) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2054 return _driver._cuLogicalEndpointGetLimits(bindAlignment, maxSize, prop)

2055

2056

2057cdef CUresult cuLogicalEndpointQuery(CUlogicalEndpointId leId, cuuint32_t count, int* queryStatus) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2058 return _driver._cuLogicalEndpointQuery(leId, count, queryStatus)

2059

2060

2061cdef CUresult cuStreamBeginRecaptureToGraph(CUstream hStream, CUstreamCaptureMode mode, CUgraph hGraph, CUgraphRecaptureCallback callbackFunc, void* userData) except ?CUDA_ERROR_NOT_FOUND nogil: (empty)

2062 return _driver._cuStreamBeginRecaptureToGraph(hStream, mode, hGraph, callbackFunc, userData)